@pendle/core-v2 1.5.0-testnet → 1.6.0-testnet

package/contracts/core/libraries/Errors.sol

@@ -116,6 +116,8 @@ library Errors {
 
     error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
 
+    error SYBalancerReentrancy();
+
     // Liquidity Mining
     error VCInactivePool(address pool);
     error VCPoolAlreadyActive(address pool);
@@ -165,6 +167,7 @@ library Errors {
     error ArrayOutOfBounds();
     error ZeroAddress();
     error FailedToSendEther();
+    error InvalidMerkleProof();
 
     error OnlyLayerZeroEndpoint();
     error OnlyYT();

package/contracts/interfaces/Balancer/IVault.sol

@@ -5,6 +5,21 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "./IAsset.sol";
 
 interface IVault {
+    enum UserBalanceOpKind {
+        DEPOSIT_INTERNAL,
+        WITHDRAW_INTERNAL,
+        TRANSFER_INTERNAL,
+        TRANSFER_EXTERNAL
+    }
+
+    struct UserBalanceOp {
+        UserBalanceOpKind kind;
+        IAsset asset;
+        uint256 amount;
+        address sender;
+        address payable recipient;
+    }
+
     struct JoinPoolRequest {
         address[] assets;
         uint256[] maxAmountsIn;
@@ -61,12 +76,14 @@ interface IVault {
         uint256 deadline
     ) external payable returns (uint256);
 
-    function getPoolTokens(
-        bytes32 poolId
-    )
+    function getPoolTokens(bytes32 poolId)
         external
         view
-        returns (IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock);
+        returns (
+            IERC20[] memory tokens,
+            uint256[] memory balances,
+            uint256 lastChangeBlock
+        );
 
     function WETH() external view returns (IERC20);
 

package/contracts/interfaces/Frax/IFrxEthMinter.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IFrxEthMinter {
+    function frxETHToken() external view returns (address);
+
+    function sfrxETHToken() external view returns (address);
+
+    function submitAndDeposit(address recipient) external payable returns (uint256 shares);
+}

package/contracts/interfaces/GMX/IGlpManager.sol

@@ -9,4 +9,6 @@ interface IGlpManager {
     function gov() external view returns (address);
 
     function setCooldownDuration(uint256 _cooldownDuration) external;
+
+    function getPrice(bool _maximise) external view returns (uint256);
 }

package/contracts/interfaces/IPFeeDistributor.sol

@@ -13,10 +13,9 @@ interface IPFeeDistributor {
         uint128 iter;
     }
 
-    function claimReward(
-        address user,
-        address[] calldata pools
-    ) external returns (uint256[] memory amountRewardOut);
+    function claimReward(address user, address[] calldata pools)
+        external
+        returns (uint256[] memory amountRewardOut);
 
     function getAllPools() external view returns (address[] memory);
 }

package/contracts/interfaces/IPFeeDistributorV2.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPFeeDistributorV2 {
+    event SetMerkleRootAndFund(bytes32 indexed merkleRoot, uint256 amountFunded);
+
+    event Claimed(address indexed user, uint256 amountOut);
+
+    event UpdateProtocolClaimable(address indexed user, uint256 sumTopUp);
+
+    struct UpdateProtocolStruct {
+        address user;
+        bytes32[] proof;
+        address[] pools;
+        uint256[] topUps;
+    }
+
+    /**
+     * @notice submit total ETH accrued & proof to claim the outstanding amount. Intended to be
+     used by retail users
+     */
+    function claimRetail(
+        address receiver,
+        uint256 totalAccrued,
+        bytes32[] calldata proof
+    ) external returns (uint256 amountOut);
+
+    /**
+     * @notice Protocols that require the use of this function & feeData should contact the Pendle team.
+     * @notice Protocols should NOT EVER use claimRetail. Using it will make getProtocolFeeData unreliable.
+     */
+    function claimProtocol(address receiver, address[] calldata pools)
+        external
+        returns (uint256 totalAmountOut, uint256[] memory amountsOut);
+
+    /**
+    * @notice returns the claimable fees per pool. Only available if the Pendle team has specifically
+    set up the data
+     */
+    function getProtocolClaimables(address user, address[] calldata pools)
+        external
+        view
+        returns (uint256[] memory claimables);
+
+    function getProtocolTotalAccrued(address user) external view returns (uint256);
+}

package/contracts/interfaces/IPMarket.sol

@@ -84,4 +84,23 @@ interface IPMarket is IERC20Metadata, IPGauge {
     function isExpired() external view returns (bool);
 
     function expiry() external view returns (uint256);
+
+    function observations(
+        uint256 index
+    )
+        external
+        view
+        returns (uint32 blockTimestamp, uint216 lnImpliedRateCumulative, bool initialized);
+
+    function _storage()
+        external
+        view
+        returns (
+            int128 totalPt,
+            int128 totalSy,
+            uint96 lastLnImpliedRate,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 observationCardinalityNext
+        );
 }

package/contracts/interfaces/IPPtOracle.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+interface IPPtOracle {
+    event SetBlockCycleNumerator(uint16 newBlockCycleNumerator);
+
+    function getPtToAssetRate(
+        address market,
+        uint32 duration
+    ) external view returns (uint256 ptToAssetRate);
+
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
+        external
+        view
+        returns (
+            bool increaseCardinalityRequired,
+            uint16 cardinalityRequired,
+            bool oldestObservationSatisfied
+        );
+}

package/contracts/interfaces/IPYieldToken.sol

@@ -62,4 +62,7 @@ interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
     function isExpired() external view returns (bool);
 
     function doCacheIndexSameBlock() external view returns (bool);
+
+    function pyIndexLastUpdatedBlock() external view returns (uint128);
+
 }

package/contracts/offchain-helpers/BoringPtSeller.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+import "../interfaces/IPMarket.sol";
+
+abstract contract BoringPtSeller {
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    constructor() {}
+
+    /// @dev slippage control should be done on a higher level with the returned parameter
+    /// @param market market address
+    /// @param netPtIn amount of Pt to sell
+    /// @param tokenOut should be included in SY.getTokensOut()
+    /// @return netTokenOut amount of token out
+    function _sellPtForToken(
+        address market,
+        uint256 netPtIn,
+        address tokenOut
+    ) internal returns (uint256 netTokenOut) {
+        (IStandardizedYield SY, IPPrincipalToken PT, IPYieldToken YT) = IPMarket(market)
+            .readTokens();
+
+        uint256 netSyOut;
+        if (PT.isExpired()) {
+            PT.transfer(address(YT), netPtIn);
+            netSyOut = YT.redeemPY(address(SY));
+        } else {
+            // safeTransfer not required
+            PT.transfer(market, netPtIn);
+            (netSyOut, ) = IPMarket(market).swapExactPtForSy(
+                address(SY), // better gas optimization to transfer SY directly to itself and burn
+                netPtIn,
+                EMPTY_BYTES
+            );
+        }
+
+        netTokenOut = SY.redeem(address(this), netSyOut, tokenOut, 0, true);
+    }
+}

package/contracts/offchain-helpers/EmptyUUPS.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract EmptyUUPS is Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
+    constructor() initializer {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+}

package/contracts/offchain-helpers/PendleMulticallV1.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+contract PendleMulticallV1 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    function aggregate(Call[] calldata calls) public payable virtual {
+        uint256 length = calls.length;
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call(call.callData);
+            if (!success) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function tryAggregate(
+        bool requireSuccess,
+        uint256 gasLimit,
+        Call[] calldata calls
+    ) public payable returns (Result[] memory returnData) {
+        uint256 length = calls.length;
+        returnData = new Result[](length);
+        Call calldata call;
+        for (uint256 i = 0; i < length; ) {
+            call = calls[i];
+
+            (bool success, bytes memory resp) = call.target.call{ gas: gasLimit }(
+                calls[i].callData
+            );
+            if (!success && requireSuccess) {
+                assembly {
+                    revert(add(32, resp), mload(resp))
+                }
+            }
+
+            returnData[i] = Result(success, resp);
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+}

package/contracts/oracles/PendlePtOracle.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "./PendlePtOracleLib.sol";
+import "../interfaces/IPPtOracle.sol";
+import "../core/libraries/BoringOwnableUpgradeable.sol";
+
+contract PendlePtOracle is BoringOwnableUpgradeable, IPPtOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    error InvalidBlockRate(uint256 blockCycleNumerator);
+    error TwapDurationTooLarge(uint32 duration, uint32 cardinalityRequired);
+
+    /// @notice Oracles will be created ensuring a lowerbound in PendleMarket oracle's cardinality
+    /// @dev Cardinality lowerbound will be calculated as twap_duration * 1000 / blockCycleNumerator
+    /// @dev blockCycleNumerator should be configured so that blockCycleNumerator / 1000 < actual block cycle
+    /// @dev blockCycleNumerator should be greater or equal to 1000 since the oracle only records one
+    /// rate per timestamp
+    /// For example, on Ethereum blockCycleNumerator = 11000, where 11000/1000 = 11 < 12
+    ///                 Arbitrum blockCycleNumerator = 1000, since we can't do better than this
+    uint16 public blockCycleNumerator;
+    uint16 public constant BLOCK_CYCLE_DENOMINATOR = 1000;
+
+    constructor(uint16 _blockCycleNumerator) initializer {
+        __BoringOwnable_init();
+        setBlockCycleNumerator(_blockCycleNumerator);
+    }
+
+    function setBlockCycleNumerator(uint16 newBlockCycleNumerator) public onlyOwner {
+        if (newBlockCycleNumerator < BLOCK_CYCLE_DENOMINATOR) {
+            revert InvalidBlockRate(newBlockCycleNumerator);
+        }
+
+        blockCycleNumerator = newBlockCycleNumerator;
+        emit SetBlockCycleNumerator(newBlockCycleNumerator);
+    }
+
+    /**
+     * This function returns the twap rate PT/Asset on market
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getPtToAssetRate(
+        address market,
+        uint32 duration
+    ) external view returns (uint256 ptToAssetRate) {
+        ptToAssetRate = IPMarket(market).getPtToAssetRate(duration);
+    }
+
+    /**
+     * A check function for the cardinality status of the market
+     * @param market PendleMarket address
+     * @param duration twap duration
+     * @return increaseCardinalityRequired a boolean indicates whether the cardinality should be increased to serve the duration
+     * @return cardinalityRequired the amount of cardinality required for the twap duration
+     */
+    function getOracleState(
+        address market,
+        uint32 duration
+    )
+        external
+        view
+        returns (
+            bool increaseCardinalityRequired,
+            uint16 cardinalityRequired,
+            bool oldestObservationSatisfied
+        )
+    {
+        (
+            ,
+            ,
+            ,
+            uint16 observationIndex,
+            uint16 observationCardinality,
+            uint16 cardinalityReserved
+        ) = IPMarket(market)._storage();
+
+        // checkIncreaseCardinalityRequired
+        cardinalityRequired = _calcCardinalityRequiredRequired(duration);
+        increaseCardinalityRequired = cardinalityReserved < cardinalityRequired;
+
+        // check oldestObservationSatisfied
+        (uint32 oldestTimestamp, , bool initialized) = IPMarket(market).observations(
+            (observationIndex + 1) % observationCardinality
+        );
+        if (!initialized) {
+            (oldestTimestamp, , ) = IPMarket(market).observations(0);
+        }
+        oldestObservationSatisfied = oldestTimestamp < block.timestamp - duration;
+    }
+
+    function _calcCardinalityRequiredRequired(uint32 duration) internal view returns (uint16) {
+        uint32 cardinalityRequired = (duration * BLOCK_CYCLE_DENOMINATOR) / blockCycleNumerator;
+        if (cardinalityRequired > type(uint16).max) {
+            revert TwapDurationTooLarge(duration, cardinalityRequired);
+        }
+        return uint16(cardinalityRequired);
+    }
+}

package/contracts/oracles/PendlePtOracleLib.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../interfaces/IPMarket.sol";
+import "../core/libraries/math/Math.sol";
+
+library PendlePtOracleLib {
+    using Math for uint256;
+
+    /**
+     * This function returns the twap rate PT/Asset on market
+     * @param market market to get rate from
+     * @param duration twap duration
+     */
+    function getPtToAssetRate(IPMarket market, uint32 duration)
+        internal
+        view
+        returns (uint256 ptToAssetRate)
+    {
+        uint256 expiry = market.expiry();
+        if (expiry <= block.timestamp) {
+            return _getPtToAssetRatePostExpiry(market);
+        }
+        uint256 lnImpliedRate = _getMarketLnImpliedRate(market, duration);
+        uint256 timeToExpiry = expiry - block.timestamp;
+        uint256 assetToPtRate = uint256(
+            MarketMathCore._getExchangeRateFromImpliedRate(lnImpliedRate, timeToExpiry)
+        );
+
+        ptToAssetRate = Math.ONE.divDown(assetToPtRate);
+    }
+
+    function _getMarketLnImpliedRate(IPMarket market, uint32 duration)
+        private
+        view
+        returns (uint256)
+    {
+        uint32[] memory durations = new uint32[](2);
+        durations[0] = duration;
+
+        uint216[] memory lnImpliedRateCumulative = market.observe(durations);
+        return (lnImpliedRateCumulative[1] - lnImpliedRateCumulative[0]) / duration;
+    }
+
+    function _getPtToAssetRatePostExpiry(IPMarket market) private view returns (uint256) {
+        (IStandardizedYield SY, , IPYieldToken YT) = market.readTokens();
+
+        uint256 syIndex = SY.exchangeRate();
+        uint256 pyIndexCurrent;
+
+        if (YT.doCacheIndexSameBlock() && YT.pyIndexLastUpdatedBlock() == block.number) {
+            pyIndexCurrent = YT.pyIndexStored();
+        } else {
+            pyIndexCurrent = Math.max(syIndex, YT.pyIndexStored());
+        }
+
+        return syIndex.divDown(pyIndexCurrent);
+    }
+}

package/contracts/oracles/samples/PendlePtGlpOracle.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../PendlePtOracleLib.sol";
+import "../../interfaces/IPPtOracle.sol";
+import "../../interfaces/GMX/IGlpManager.sol";
+import "../../core/libraries/math/Math.sol";
+
+/**
+ * @notice The returned price from this contract is multiply with the USD price of GLP read from
+ * GLPManager contract
+ *
+ * @dev This contract uses the PendlePtOracleLibrary to get the price instead of calling PendlePtOracle contract
+ * to save 1 external call gas consumption
+ */
+contract PendlePtGlpOracle {
+    using PendlePtOracleLib for IPMarket;
+
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable glpManager;
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _glpManager
+    ) {
+        twapDuration = _twapDuration;
+        market = _market;
+        glpManager = _glpManager;
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getPtPrice() external view virtual returns (uint256) {
+        // using library directly to save 1 external call (gas optimization)
+        uint256 ptRate = IPMarket(market).getPtToAssetRate(twapDuration);
+        uint256 assetPrice = IGlpManager(glpManager).getPrice(true);
+        return (assetPrice * ptRate) / (10 ** 30);
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/contracts/oracles/samples/PendlePtUsdChainlinkOracle.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPPtOracle.sol";
+import "../../core/libraries/math/Math.sol";
+import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+
+/**
+ * @notice The returned price from this contract is multiply with the default USD price of asset
+ * read from Chainlink Oracles
+ *
+ * @dev The ptRate is fetched from PendlePtOracle contract
+ */
+contract PendlePtUsdChainlinkOracle {
+    address public immutable ptOracle;
+    uint32 public immutable twapDuration;
+    address public immutable market;
+    address public immutable feed;
+    uint8 public immutable feedDecimals;
+
+    error OracleNotReady(bool increaseCardinalityRequired, bool oldestObservationSatisfied);
+
+    constructor(
+        address _ptOracle,
+        uint32 _twapDuration,
+        address _market,
+        address _feed
+    ) {
+        ptOracle = _ptOracle;
+        twapDuration = _twapDuration;
+        market = _market;
+        feed = _feed;
+        feedDecimals = IChainlinkAggregator(feed).decimals();
+
+        (bool increaseCardinalityRequired, , bool oldestObservationSatisfied) = IPPtOracle(
+            _ptOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired || !oldestObservationSatisfied) {
+            revert OracleNotReady(increaseCardinalityRequired, oldestObservationSatisfied);
+        }
+    }
+
+    function getPtPrice() external view virtual returns (uint256) {
+        uint256 ptRate = IPPtOracle(ptOracle).getPtToAssetRate(market, twapDuration);
+        uint256 assetPrice = _getUnderlyingAssetPrice();
+        return (assetPrice * ptRate) / Math.ONE;
+    }
+
+    function _getUnderlyingAssetPrice() internal view virtual returns (uint256) {
+        uint256 rawPrice = uint256(IChainlinkAggregator(feed).latestAnswer());
+        return
+            feedDecimals < 18
+                ? rawPrice * 10**(18 - feedDecimals)
+                : rawPrice / 10**(feedDecimals - 18);
+    }
+
+    function decimals() external pure virtual returns (uint8) {
+        return 18;
+    }
+}

package/deployments/43113-core.json

@@ -27,5 +27,6 @@
     "senderEndpoint": "0x86bD575c36e236386284C035ffeBE66CB6ecd2DD",
     "votingController": "0x40ea97a7E9A4A0520229d1bbdf4D82E36b1a5475",
     "gaugeController": "0x90Fa61ea34f61e31e9471CEB0ED22b12bBf4263E",
-    "feeDistributor": "0x40160f3439317bCD0ec8eB09545dD6A30771A7B6"
+    "feeDistributor": "0x40160f3439317bCD0ec8eB09545dD6A30771A7B6",
+    "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9"
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "1.5.0-testnet",
+  "version": "1.6.0-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,9 +25,9 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.13.0",
+    "hardhat": "^2.13.1",
     "hardhat-contract-sizer": "^2.8.0",
-    "prettier": "^2.8.5",
+    "prettier": "^2.8.7",
     "prettier-plugin-solidity": "^1.1.3",
     "solc": "^0.8.19",
     "solhint": "^3.4.1",
@@ -44,6 +44,7 @@
   },
   "packageManager": "yarn@3.3.1",
   "dependencies": {
+    "@chainlink/contracts": "^0.6.1",
     "@openzeppelin/contracts": "4.7.3",
     "@openzeppelin/contracts-upgradeable": "4.7.3"
   }