@pendle/core-v2 1.4.0-mainnet → 1.4.1-testnet

package/contracts/core/StandardizedYield/implementations/PendleGdaiSY.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../SYBase.sol";
+import "../../../interfaces/IERC4626.sol";
+
+contract PendleGDaiSY is SYBase {
+    address public immutable DAI;
+    address public immutable gDAI;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _gDAI
+    ) SYBase(_name, _symbol, _gDAI) {
+        gDAI = _gDAI;
+        DAI = IERC4626(gDAI).asset();
+        _safeApproveInf(DAI, gDAI);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * The underlying yield token is gDAI. If the base token deposited is DAI, the function
+     * deposits received DAI into the gDAI contract.
+     */
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == gDAI) {
+            return amountDeposited;
+        } else {
+            return IERC4626(gDAI).deposit(amountDeposited, address(this));
+        }
+    }
+
+    /**
+     * Only withdrawal to gDAI is supported.
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev It is the exchange rate of gDAI to DAI
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IERC4626(gDAI).convertToAssets(1e18);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == gDAI) {
+            return amountTokenToDeposit;
+        } else {
+            return IERC4626(gDAI).previewDeposit(amountTokenToDeposit);
+        }
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](2);
+        res[0] = DAI;
+        res[1] = gDAI;
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = gDAI;
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == DAI || token == gDAI;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == gDAI;
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
+        return (AssetType.TOKEN, DAI, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/PendleLooksStakingSY.sol

@@ -30,12 +30,10 @@ contract PendleLooksStakingSY is SYBase {
                     DEPOSIT/REDEEM USING BASE TOKENS
     //////////////////////////////////////////////////////////////*/
 
-    function _deposit(address, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _deposit(
+        address,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
         uint256 previousShare = ILooksStaking(stakingContract).userInfo(address(this));
         ILooksStaking(stakingContract).deposit(amountDeposited);
         amountSharesOut = ILooksStaking(stakingContract).userInfo(address(this)) - previousShare;
@@ -65,22 +63,18 @@ contract PendleLooksStakingSY is SYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
         (uint256 totalShares, uint256 totalLooks) = _getLooksStakingParams();
         amountSharesOut = (amountTokenToDeposit * totalShares) / totalLooks;
     }
 
-    function _previewRedeem(address, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
         (uint256 totalShares, uint256 totalLooks) = _getLooksStakingParams();
         amountTokenOut = (amountSharesToRedeem * totalLooks) / totalShares;
     }
@@ -117,11 +111,7 @@ contract PendleLooksStakingSY is SYBase {
     function assetInfo()
         external
         view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
     {
         return (AssetType.TOKEN, looks, IERC20Metadata(looks).decimals());
     }

package/contracts/core/StandardizedYield/implementations/PendleWstEthSY.sol

@@ -35,12 +35,10 @@ contract PendleWstEthSY is SYBase {
      *
      * The exchange rate of wstETH to shares is 1:1
      */
-    function _deposit(address tokenIn, uint256 amountDeposited)
-        internal
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
         if (tokenIn == wstETH) {
             amountSharesOut = amountDeposited;
         } else {
@@ -94,12 +92,10 @@ contract PendleWstEthSY is SYBase {
                 MISC FUNCTIONS FOR METADATA
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
         if (tokenIn == wstETH) amountSharesOut = amountTokenToDeposit;
         else {
             if (tokenIn != stETH) {
@@ -120,12 +116,10 @@ contract PendleWstEthSY is SYBase {
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
         if (tokenOut == wstETH) amountTokenOut = amountSharesToRedeem;
         else amountTokenOut = IStETH(stETH).getPooledEthByShares(amountSharesToRedeem);
     }
@@ -155,11 +149,7 @@ contract PendleWstEthSY is SYBase {
     function assetInfo()
         external
         view
-        returns (
-            AssetType assetType,
-            address assetAddress,
-            uint8 assetDecimals
-        )
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
     {
         return (AssetType.TOKEN, stETH, IERC20Metadata(stETH).decimals());
     }

package/contracts/core/YieldContracts/PendleYieldToken.sol

@@ -90,13 +90,10 @@ contract PendleYieldToken is
      * @notice Tokenize SY into PT + YT of equal qty. Every unit of asset of SY will create 1 PT + 1 YT
      * @dev SY must be transferred to this contract prior to calling
      */
-    function mintPY(address receiverPT, address receiverYT)
-        external
-        nonReentrant
-        notExpired
-        updateData
-        returns (uint256 amountPYOut)
-    {
+    function mintPY(
+        address receiverPT,
+        address receiverYT
+    ) external nonReentrant notExpired updateData returns (uint256 amountPYOut) {
         address[] memory receiverPTs = new address[](1);
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
@@ -135,12 +132,9 @@ contract PendleYieldToken is
      * same time
      * @dev PT/YT must be transferred to this contract prior to calling
      */
-    function redeemPY(address receiver)
-        external
-        nonReentrant
-        updateData
-        returns (uint256 amountSyOut)
-    {
+    function redeemPY(
+        address receiver
+    ) external nonReentrant updateData returns (uint256 amountSyOut) {
         address[] memory receivers = new address[](1);
         uint256[] memory amounts = new uint256[](1);
         (receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
@@ -156,12 +150,10 @@ contract PendleYieldToken is
      * @dev PT/YT must be transferred to this contract prior to calling
      * @dev fails if unable to redeem the total PY amount in `amountPYToRedeems`
      */
-    function redeemPYMulti(address[] calldata receivers, uint256[] calldata amountPYToRedeems)
-        external
-        nonReentrant
-        updateData
-        returns (uint256[] memory amountSyOuts)
-    {
+    function redeemPYMulti(
+        address[] calldata receivers,
+        uint256[] calldata amountPYToRedeems
+    ) external nonReentrant updateData returns (uint256[] memory amountSyOuts) {
         if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
         if (receivers.length == 0) revert Errors.ArrayEmpty();
         amountSyOuts = _redeemPY(receivers, amountPYToRedeems);
@@ -329,10 +321,10 @@ contract PendleYieldToken is
         return MiniHelpers.isCurrentlyExpired(expiry);
     }
 
-    function _redeemPY(address[] memory receivers, uint256[] memory amountPYToRedeems)
-        internal
-        returns (uint256[] memory amountSyOuts)
-    {
+    function _redeemPY(
+        address[] memory receivers,
+        uint256[] memory amountPYToRedeems
+    ) internal returns (uint256[] memory amountSyOuts) {
         uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
         IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
         if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
@@ -357,20 +349,18 @@ contract PendleYieldToken is
         }
     }
 
-    function _calcPYToMint(uint256 amountSy, uint256 indexCurrent)
-        internal
-        pure
-        returns (uint256 amountPY)
-    {
+    function _calcPYToMint(
+        uint256 amountSy,
+        uint256 indexCurrent
+    ) internal pure returns (uint256 amountPY) {
         // doesn't matter before or after expiry, since mintPY is only allowed before expiry
         return SYUtils.syToAsset(indexCurrent, amountSy);
     }
 
-    function _calcSyRedeemableFromPY(uint256 amountPY, uint256 indexCurrent)
-        internal
-        view
-        returns (uint256 syToUser, uint256 syInterestPostExpiry)
-    {
+    function _calcSyRedeemableFromPY(
+        uint256 amountPY,
+        uint256 indexCurrent
+    ) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {
         syToUser = SYUtils.assetToSy(indexCurrent, amountPY);
         if (isExpired()) {
             uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);
@@ -443,12 +433,10 @@ contract PendleYieldToken is
         return IStandardizedYield(SY).getRewardTokens();
     }
 
-    function _doTransferOutRewards(address user, address receiver)
-        internal
-        virtual
-        override
-        returns (uint256[] memory rewardAmounts)
-    {
+    function _doTransferOutRewards(
+        address user,
+        address receiver
+    ) internal virtual override returns (uint256[] memory rewardAmounts) {
         address[] memory tokens = getRewardTokens();
 
         if (isExpired()) {
@@ -519,11 +507,7 @@ contract PendleYieldToken is
     }
 
     //solhint-disable-next-line ordering
-    function _beforeTokenTransfer(
-        address from,
-        address to,
-        uint256
-    ) internal override {
+    function _beforeTokenTransfer(address from, address to, uint256) internal override {
         if (isExpired()) _setPostExpiryData();
         _updateAndDistributeRewardsForTwo(from, to);
         _distributeInterestForTwo(from, to);

package/contracts/core/YieldContractsV2/InterestManagerYTV2.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPYieldToken.sol";
+import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPInterestManagerYTV2.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import "../libraries/math/Math.sol";
+import "../libraries/TokenHelper.sol";
+import "../StandardizedYield/SYUtils.sol";
+
+/*
+With YT yielding more SYs overtime, which is allowed to be redeemed by users, the reward distribution should
+be based on the amount of SYs that their YT currently represent, plus with their dueInterest.
+
+It has been proven and tested that totalSyRedeemable will not change over time, unless users redeem their interest or redeemPY.
+
+Due to this, it is required to update users' accruedReward STRICTLY BEFORE redeeming their interest.
+*/
+abstract contract InterestManagerYTV2 is TokenHelper, IPInterestManagerYTV2 {
+    using Math for uint256;
+
+    struct UserInterest {
+        uint128 index;
+        uint128 accrued;
+        uint256 pyIndex;
+    }
+
+    uint256 public lastInterestBlock;
+
+    uint256 public globalInterestIndex;
+
+    mapping(address => UserInterest) public userInterest;
+
+    uint256 internal constant INITIAL_INTEREST_INDEX = 1;
+
+    function _updateAndDistributeInterest(address user) internal virtual {
+        _updateAndDistributeInterestForTwo(user, address(0));
+    }
+
+    function _updateAndDistributeInterestForTwo(address user1, address user2) internal virtual {
+        (uint256 index, uint256 pyIndex) = _updateInterestIndex();
+
+        if (user1 != address(0) && user1 != address(this))
+            _distributeInterestPrivate(user1, index, pyIndex);
+        if (user2 != address(0) && user2 != address(this))
+            _distributeInterestPrivate(user2, index, pyIndex);
+    }
+
+    function _doTransferOutInterest(
+        address user,
+        address SY
+    ) internal returns (uint256 interestAmount) {
+        interestAmount = userInterest[user].accrued;
+        userInterest[user].accrued = 0;
+        _transferOut(SY, user, interestAmount);
+    }
+
+    // should only be callable from `_distributeInterestForTwo` & make sure user != address(0) && user != address(this)
+    function _distributeInterestPrivate(
+        address user,
+        uint256 currentIndex,
+        uint256 pyIndex
+    ) private {
+        assert(user != address(0) && user != address(this));
+
+        uint256 prevIndex = userInterest[user].index;
+        // uint256 interestFeeRate = _getInterestFeeRate();
+
+        if (prevIndex == currentIndex) return;
+
+        if (prevIndex == 0) {
+            userInterest[user].index = currentIndex.Uint128();
+            userInterest[user].pyIndex = pyIndex;
+            return;
+        }
+
+        userInterest[user].accrued += _YTbalance(user).mulDown(currentIndex - prevIndex).Uint128();
+        userInterest[user].index = currentIndex.Uint128();
+        userInterest[user].pyIndex = pyIndex;
+    }
+
+    function _updateInterestIndex() internal returns (uint256 index, uint256 pyIndex) {
+        if (lastInterestBlock != block.number) {
+            // if we have not yet update the index for this block
+            lastInterestBlock = block.number;
+
+            uint256 totalShares = _YTSupply();
+            uint256 accrued;
+
+            (accrued, pyIndex) = _collectInterest();
+            index = globalInterestIndex;
+
+            if (index == 0) index = INITIAL_INTEREST_INDEX;
+            if (totalShares != 0) index += accrued.divDown(totalShares);
+
+            globalInterestIndex = index;
+        } else {
+            index = globalInterestIndex;
+            pyIndex = _getGlobalPYIndex();
+        }
+    }
+
+    function _getGlobalPYIndex() internal view virtual returns (uint256);
+
+    function _collectInterest() internal virtual returns (uint256, uint256);
+
+    function _YTbalance(address user) internal view virtual returns (uint256);
+
+    function _YTSupply() internal view virtual returns (uint256);
+}

package/contracts/core/YieldContractsV2/PendlePrincipalTokenV2.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPPrincipalToken.sol";
+import "../../interfaces/IPYieldToken.sol";
+
+import "../libraries/MiniHelpers.sol";
+import "../libraries/Errors.sol";
+
+import "../erc20/PendleERC20Permit.sol";
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+contract PendlePrincipalTokenV2 is PendleERC20Permit, Initializable, IPPrincipalToken {
+    address public immutable SY;
+    address public immutable factory;
+    uint256 public immutable expiry;
+    address public YT;
+
+    modifier onlyYT() {
+        if (msg.sender != YT) revert Errors.OnlyYT();
+        _;
+    }
+
+    modifier onlyYieldFactory() {
+        if (msg.sender != factory) revert Errors.OnlyYCFactory();
+        _;
+    }
+
+    constructor(
+        address _SY,
+        string memory _name,
+        string memory _symbol,
+        uint8 __decimals,
+        uint256 _expiry
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
+        SY = _SY;
+        expiry = _expiry;
+        factory = msg.sender;
+    }
+
+    function initialize(address _YT) external initializer onlyYieldFactory {
+        YT = _YT;
+    }
+
+    /**
+     * @dev only callable by the YT correspond to this PT
+     */
+    function burnByYT(address user, uint256 amount) external onlyYT {
+        _burn(user, amount);
+    }
+
+    /**
+     * @dev only callable by the YT correspond to this PT
+     */
+    function mintByYT(address user, uint256 amount) external onlyYT {
+        _mint(user, amount);
+    }
+
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
+}