@pendle/core-v2 3.0.0-beta-9 → 3.0.0

package/contracts/core/StandardizedYield/implementations/Convex/base/PendleConvexLPSY.sol

@@ -35,9 +35,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         _safeApproveInf(crvLp, BOOSTER);
     }
 
-    function _getPoolInfo(
-        uint256 _cvxPid
-    ) internal view returns (address _crvLp, address _cvxRewardManager) {
+    function _getPoolInfo(uint256 _cvxPid) internal view returns (address _crvLp, address _cvxRewardManager) {
         if (_cvxPid > IBooster(BOOSTER).poolLength()) revert Errors.SYCurveInvalidPid();
 
         (_crvLp, , , _cvxRewardManager, , ) = IBooster(BOOSTER).poolInfo(_cvxPid);
@@ -51,10 +49,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
      * If any of the base pool tokens are deposited, it will first add liquidity to the curve pool and mint LP,
      * which will then be deposited into convex
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount) internal virtual override returns (uint256 amountSharesOut) {
         if (tokenIn == crvLp) {
             amountSharesOut = amount;
         } else {
@@ -148,15 +143,9 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
 
     function isValidTokenOut(address token) public view virtual override returns (bool);
 
-    function _depositToCurve(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal virtual returns (uint256);
+    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit) internal virtual returns (uint256);
 
-    function _redeemFromCurve(
-        address tokenOut,
-        uint256 amountLpToRedeem
-    ) internal virtual returns (uint256);
+    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem) internal virtual returns (uint256);
 
     function _previewDepositToCurve(
         address token,
@@ -168,11 +157,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         uint256 amountLpToRedeem
     ) internal view virtual returns (uint256 amountTokenOut);
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.LIQUIDITY, crvLp, IERC20Metadata(crvLp).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/Flux/FluxTokenLib.sol

@@ -28,8 +28,7 @@ library FluxTokenLib {
         params.currentBlockNumber = block.number;
         params.accrualBlockNumberPrior = IFluxErc20(fToken).accrualBlockNumber();
 
-        if (params.accrualBlockNumberPrior == params.currentBlockNumber)
-            return IFluxErc20(fToken).exchangeRateStored();
+        if (params.accrualBlockNumberPrior == params.currentBlockNumber) return IFluxErc20(fToken).exchangeRateStored();
 
         /* Read the previous values out of storage */
         params.cashPrior = IFluxErc20(fToken).getCash();
@@ -37,8 +36,11 @@ library FluxTokenLib {
         params.reservesPrior = IFluxErc20(fToken).totalReserves();
 
         /* Calculate the current borrow interest rate */
-        params.borrowRateMantissa = IFluxInterestRateModel(IFluxErc20(fToken).interestRateModel())
-            .getBorrowRate(params.cashPrior, params.borrowsPrior, params.reservesPrior);
+        params.borrowRateMantissa = IFluxInterestRateModel(IFluxErc20(fToken).interestRateModel()).getBorrowRate(
+            params.cashPrior,
+            params.borrowsPrior,
+            params.reservesPrior
+        );
 
         assert(params.borrowRateMantissa <= borrowRateMaxMantissa);
 

package/contracts/core/StandardizedYield/implementations/Flux/PendleFluxLendingSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./FluxTokenLib.sol";
 import "../../SYBase.sol";
@@ -13,11 +13,7 @@ contract PendleFluxLendingSY is SYBase {
     address public immutable fToken;
     address public immutable underlying;
 
-    constructor(
-        string memory _name,
-        string memory _symbol,
-        address _fToken
-    ) SYBase(_name, _symbol, _fToken) {
+    constructor(string memory _name, string memory _symbol, address _fToken) SYBase(_name, _symbol, _fToken) {
         // underlying
         fToken = _fToken;
         underlying = IFluxErc20(_fToken).underlying();
@@ -101,11 +97,7 @@ contract PendleFluxLendingSY is SYBase {
         return token == fToken || token == underlying;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/GLP/GLPPreviewHelper.sol

@@ -76,8 +76,7 @@ abstract contract GLPPreviewHelper {
         uint256 _amount,
         uint256 _feeBasisPoints
     ) private pure returns (uint256) {
-        uint256 afterFeeAmount = (_amount * (BASIS_POINTS_DIVISOR - _feeBasisPoints)) /
-            (BASIS_POINTS_DIVISOR);
+        uint256 afterFeeAmount = (_amount * (BASIS_POINTS_DIVISOR - _feeBasisPoints)) / (BASIS_POINTS_DIVISOR);
         return afterFeeAmount;
     }
 
@@ -109,9 +108,7 @@ abstract contract GLPPreviewHelper {
         uint256 initialDiff = initialAmount > targetAmount
             ? initialAmount - targetAmount
             : targetAmount - initialAmount;
-        uint256 nextDiff = nextAmount > targetAmount
-            ? nextAmount - targetAmount
-            : targetAmount - nextAmount;
+        uint256 nextDiff = nextAmount > targetAmount ? nextAmount - targetAmount : targetAmount - nextAmount;
 
         // action improves relative asset balance
         if (nextDiff < initialDiff) {
@@ -127,10 +124,7 @@ abstract contract GLPPreviewHelper {
         return _feeBasisPoints + taxBps;
     }
 
-    function __getTargetUsdgAmount(
-        address _token,
-        uint256 _burnedUsdg
-    ) private view returns (uint256) {
+    function __getTargetUsdgAmount(address _token, uint256 _burnedUsdg) private view returns (uint256) {
         uint256 supply = IERC20(usdg).totalSupply() - _burnedUsdg;
         if (supply == 0) {
             return 0;

package/contracts/core/StandardizedYield/implementations/GLP/GMTokenPricingHelper.sol

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../../../libraries/BoringOwnableUpgradeable.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+interface IGMXV2Oracle {
+    function getPriceFeedMultiplier(address dataStore, address token) external view returns (uint256);
+}
+
+interface IGMXV2DataStore {
+    function getAddress(bytes32 key) external view returns (address);
+}
+
+interface IGMXV2Reader {
+    struct PriceProps {
+        uint256 min;
+        uint256 max;
+    }
+    struct MarketProps {
+        address marketToken;
+        address indexToken;
+        address longToken;
+        address shortToken;
+    }
+    struct MarketPoolValueInfoProps {
+        int256 poolValue;
+        int256 longPnl;
+        int256 shortPnl;
+        int256 netPnl;
+        uint256 longTokenAmount;
+        uint256 shortTokenAmount;
+        uint256 longTokenUsd;
+        uint256 shortTokenUsd;
+        uint256 totalBorrowingFees;
+        uint256 borrowingFeePoolFactor;
+        uint256 impactPoolAmount;
+    }
+
+    function getMarketTokenPrice(
+        address dataStore,
+        MarketProps memory market,
+        PriceProps memory indexTokenPrice,
+        PriceProps memory longTokenPrice,
+        PriceProps memory shortTokenPrice,
+        bytes32 pnlFactorType,
+        bool maximize
+    ) external view returns (int256, MarketPoolValueInfoProps memory);
+}
+
+contract GMTokenPricingHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
+    uint256 constant FLOAT_PRECISION = 10 ** 30;
+    bytes32 public constant MARKET_TOKEN = keccak256(abi.encode("MARKET_TOKEN"));
+    bytes32 public constant INDEX_TOKEN = keccak256(abi.encode("INDEX_TOKEN"));
+    bytes32 public constant LONG_TOKEN = keccak256(abi.encode("LONG_TOKEN"));
+    bytes32 public constant SHORT_TOKEN = keccak256(abi.encode("SHORT_TOKEN"));
+    bytes32 public constant PRICE_FEED = keccak256(abi.encode("PRICE_FEED"));
+    bytes32 public constant MAX_PNL_FACTOR_FOR_DEPOSITS = keccak256(abi.encode("MAX_PNL_FACTOR_FOR_DEPOSITS"));
+
+    IGMXV2Oracle constant oracle = IGMXV2Oracle(0xa11B501c2dd83Acd29F6727570f2502FAaa617F2);
+    IGMXV2DataStore constant datastore = IGMXV2DataStore(0xFD70de6b91282D8017aA4E741e9Ae325CAb992d8);
+    IGMXV2Reader constant reader = IGMXV2Reader(0xf60becbba223EEA9495Da3f606753867eC10d139);
+
+    constructor() initializer {}
+
+    function getPrice(address gm) external view returns (uint256) {
+        IGMXV2Reader.MarketProps memory prop = _getMarketProps(datastore, gm);
+        (int256 marketPrice, ) = reader.getMarketTokenPrice(
+            address(datastore),
+            prop,
+            _getTokenPrice(prop.indexToken),
+            _getTokenPrice(prop.longToken),
+            _getTokenPrice(prop.shortToken),
+            MAX_PNL_FACTOR_FOR_DEPOSITS,
+            true
+        );
+
+        // price from gmx is in based 30 when token decimals is 18
+        // while GM token should always be 18 decimals
+        return uint256(marketPrice) / 10 ** 12;
+    }
+
+    function _getTokenPrice(address token) internal view returns (IGMXV2Reader.PriceProps memory price) {
+        (, int256 latestAnswer, , , ) = IChainlinkAggregator(datastore.getAddress(_priceFeedKey(token)))
+            .latestRoundData();
+
+        uint256 multipler = oracle.getPriceFeedMultiplier(address(datastore), token);
+        uint256 adjustedPrice = (uint256(latestAnswer) * multipler) / FLOAT_PRECISION;
+        return IGMXV2Reader.PriceProps({min: adjustedPrice, max: adjustedPrice});
+    }
+
+    function _getMarketProps(
+        IGMXV2DataStore dataStore,
+        address key
+    ) internal view returns (IGMXV2Reader.MarketProps memory) {
+        IGMXV2Reader.MarketProps memory prop;
+        prop.marketToken = dataStore.getAddress(keccak256(abi.encode(key, MARKET_TOKEN)));
+        prop.indexToken = dataStore.getAddress(keccak256(abi.encode(key, INDEX_TOKEN)));
+        prop.longToken = dataStore.getAddress(keccak256(abi.encode(key, LONG_TOKEN)));
+        prop.shortToken = dataStore.getAddress(keccak256(abi.encode(key, SHORT_TOKEN)));
+        return prop;
+    }
+
+    function _priceFeedKey(address token) internal pure returns (bytes32) {
+        return keccak256(abi.encode(PRICE_FEED, token));
+    }
+
+    /////////////////// UPGRADABLE LOGIC ///////////////////////////
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/core/StandardizedYield/implementations/GLP/PendleGMV2TokenSY.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../../../interfaces/IPPriceFeed.sol";
+import "../../../../interfaces/IPLinearDistributor.sol";
+import "../../SYBaseWithRewards.sol";
+import "../../../libraries/ArrayLib.sol";
+import "./GMTokenPricingHelper.sol";
+
+contract PendleGMV2TokenSY is SYBaseWithRewards, IPPriceFeed {
+    using ArrayLib for address[];
+
+    address public immutable gm;
+    address public immutable arb;
+    address public immutable linearDistributor;
+    address public immutable pricingHelper;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _gm,
+        address _arb,
+        address _linearDistributor,
+        address _pricingHelper
+    ) SYBaseWithRewards(_name, _symbol, _gm) {
+        gm = _gm;
+        arb = _arb;
+        linearDistributor = _linearDistributor;
+        pricingHelper = _pricingHelper;
+
+        _safeApproveInf(_arb, _linearDistributor);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(
+        address /*tokenIn*/,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(gm, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        return ArrayLib.create(arb);
+    }
+
+    function _redeemExternalReward() internal override {
+        uint256 amountToVest = _getFloatingArbReward();
+        if (amountToVest > 0) {
+            IPLinearDistributor(linearDistributor).queueVestAndClaim(arb, amountToVest);
+        } else {
+            IPLinearDistributor(linearDistributor).claim(arb);
+        }
+    }
+
+    function _getFloatingArbReward() internal view returns (uint256) {
+        RewardState memory state = rewardState[arb];
+        return _selfBalance(arb) - state.lastBalance;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address /*tokenIn*/,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(gm);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(gm);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == gm;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == gm;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.LIQUIDITY, gm, IERC20Metadata(gm).decimals());
+    }
+
+    function getPrice() external view returns (uint256) {
+        return GMTokenPricingHelper(pricingHelper).getPrice(gm);
+    }
+}

package/contracts/core/StandardizedYield/implementations/GLP/PendleGlpSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "./GLPPreviewHelper.sol";
@@ -63,17 +63,9 @@ contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
             // GLP is already staked in stakedGlp's transferFrom, called in _transferIn()
             amountSharesOut = amountDeposited;
         } else if (tokenIn == NATIVE) {
-            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlpETH{ value: msg.value }(
-                0,
-                0
-            );
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlpETH{value: msg.value}(0, 0);
         } else {
-            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlp(
-                tokenIn,
-                amountDeposited,
-                0,
-                0
-            );
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlp(tokenIn, amountDeposited, 0, 0);
         }
     }
 
@@ -149,9 +141,7 @@ contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
             uint256 glpSupply = IERC20(glp).totalSupply();
             uint256 usdgAmount = super._buyUSDG(tokenIn, amountTokenToDeposit);
 
-            uint256 mintAmount = aumInUsdg == 0
-                ? usdgAmount
-                : (usdgAmount * glpSupply) / aumInUsdg;
+            uint256 mintAmount = aumInUsdg == 0 ? usdgAmount : (usdgAmount * glpSupply) / aumInUsdg;
             amountSharesOut = mintAmount;
         }
     }
@@ -204,11 +194,7 @@ contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
         return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.LIQUIDITY, glp, IERC20Metadata(glp).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/HMX/HLPPricingHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
@@ -15,7 +15,6 @@ contract HLPPricingHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
         hlp = _hlp;
     }
 
-
     function initialize() external initializer {
         __BoringOwnable_init();
     }
@@ -25,6 +24,6 @@ contract HLPPricingHelper is BoringOwnableUpgradeable, UUPSUpgradeable {
     function getPrice() external view returns (uint256) {
         uint256 aum = IHMXCalculator(hmxCalculator).getAUME30(true);
         uint256 supply = IERC20(hlp).totalSupply();
-        return aum * 1e6 / supply;
+        return (aum * 1e6) / supply;
     }
-}
+}

package/contracts/core/StandardizedYield/implementations/HMX/PendleHlpSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "../../../libraries/ArrayLib.sol";
@@ -58,12 +58,10 @@ contract PendleHlpSY is SYBaseWithRewards {
     /**
      * @dev See {SYBase-_deposit}
      */
-    function _deposit(address, /*tokenIn*/ uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 /*amountSharesOut*/ )
-    {
+    function _deposit(
+        address,
+        /*tokenIn*/ uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
         IHLPStaking(hlpStakingPool).deposit(address(this), amountDeposited);
         return amountDeposited;
     }
@@ -71,12 +69,11 @@ contract PendleHlpSY is SYBaseWithRewards {
     /**
      * @dev See {SYBase-_redeem}
      */
-    function _redeem(address receiver, address, /*tokenOut*/ uint256 amountSharesToRedeem)
-        internal
-        virtual
-        override
-        returns (uint256 /*amountTokenOut*/ )
-    {
+    function _redeem(
+        address receiver,
+        address,
+        /*tokenOut*/ uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
         IHLPStaking(hlpStakingPool).withdraw(amountSharesToRedeem);
         _transferOut(hlp, receiver, amountSharesToRedeem);
         return amountSharesToRedeem;
@@ -124,21 +121,17 @@ contract PendleHlpSY is SYBaseWithRewards {
                     MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address, /*tokenIn*/ uint256 amountTokenToDeposit)
-        internal
-        pure
-        override
-        returns (uint256 /*amountSharesOut*/ )
-    {
+    function _previewDeposit(
+        address,
+        /*tokenIn*/ uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
         return amountTokenToDeposit;
     }
 
-    function _previewRedeem(address, /*tokenOut*/ uint256 amountSharesToRedeem)
-        internal
-        pure
-        override
-        returns (uint256 /*amountTokenOut*/ )
-    {
+    function _previewRedeem(
+        address,
+        /*tokenOut*/ uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
         return amountSharesToRedeem;
     }