@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-12

package/contracts/core/YieldContracts/PendleYieldToken.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/token/ERC20/utils/SafeERC20.sol";
 
@@ -23,12 +23,7 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldToken is
-    IPYieldToken,
-    PendleERC20Permit,
-    RewardManagerAbstract,
-    InterestManagerYT
-{
+contract PendleYieldToken is IPYieldToken, PendleERC20Permit, RewardManagerAbstract, InterestManagerYT {
     using PMath for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -98,11 +93,7 @@ contract PendleYieldToken is
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
 
-        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
-            receiverPT,
-            receiverYT,
-            _getFloatingSyAmount()
-        );
+        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (receiverPT, receiverYT, _getFloatingSyAmount());
 
         uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
         amountPYOut = amountPYOuts[0];
@@ -117,8 +108,7 @@ contract PendleYieldToken is
         uint256 length = receiverPTs.length;
 
         if (length == 0) revert Errors.ArrayEmpty();
-        if (receiverYTs.length != length || amountSyToMints.length != length)
-            revert Errors.ArrayLengthMismatch();
+        if (receiverYTs.length != length || amountSyToMints.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalSyToMint = amountSyToMints.sum();
         if (totalSyToMint > _getFloatingSyAmount())
@@ -132,9 +122,7 @@ 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());
@@ -218,6 +206,7 @@ contract PendleYieldToken is
 
         for (uint256 i = 0; i < tokens.length; i++) {
             rewardsOut[i] = _selfBalance(tokens[i]) - postExpiry.userRewardOwed[tokens[i]];
+            emit CollectRewardFee(tokens[i], rewardsOut[i]);
         }
 
         _transferOut(tokens, treasury, rewardsOut);
@@ -225,6 +214,8 @@ contract PendleYieldToken is
         interestOut = postExpiry.totalSyInterestForTreasury;
         postExpiry.totalSyInterestForTreasury = 0;
         _transferOut(SY, treasury, interestOut);
+
+        emit CollectInterestFee(interestOut);
     }
 
     /// @notice updates and returns the reward indexes
@@ -307,13 +298,7 @@ contract PendleYieldToken is
             _mint(receiverYTs[i], amountPYOuts[i]);
             IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
 
-            emit Mint(
-                msg.sender,
-                receiverPTs[i],
-                receiverYTs[i],
-                amountSyToMints[i],
-                amountPYOuts[i]
-            );
+            emit Mint(msg.sender, receiverPTs[i], receiverYTs[i], amountSyToMints[i], amountPYOuts[i]);
         }
     }
 
@@ -335,10 +320,7 @@ contract PendleYieldToken is
 
         for (uint256 i = 0; i < receivers.length; i++) {
             uint256 syInterestPostExpiry;
-            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
-                amountPYToRedeems[i],
-                index
-            );
+            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(amountPYToRedeems[i], index);
             _transferOut(SY, receivers[i], amountSyOuts[i]);
             totalSyInterestPostExpiry += syInterestPostExpiry;
 
@@ -349,10 +331,7 @@ 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);
     }
@@ -407,12 +386,9 @@ contract PendleYieldToken is
     }
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
-            return _pyIndexStored;
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number) return _pyIndexStored;
 
-        uint128 index128 = PMath
-            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
-            .Uint128();
+        uint128 index128 = PMath.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored).Uint128();
 
         currentIndex = index128;
         _pyIndexStored = index128;
@@ -477,6 +453,8 @@ contract PendleYieldToken is
 
             _transferOut(tokens[i], treasury, feeAmount);
             _transferOut(tokens[i], receiver, rewardAmounts[i]);
+
+            emit CollectRewardFee(tokens[i], feeAmount);
         }
     }
 
@@ -491,16 +469,11 @@ contract PendleYieldToken is
         return SYUtils.assetToSy(index, balanceOf(user)) + userInterest[user].accrued;
     }
 
-    function _updateRewardIndex()
-        internal
-        override
-        returns (address[] memory tokens, uint256[] memory indexes)
-    {
+    function _updateRewardIndex() internal override returns (address[] memory tokens, uint256[] memory indexes) {
         tokens = getRewardTokens();
         if (isExpired()) {
             indexes = new uint256[](tokens.length);
-            for (uint256 i = 0; i < tokens.length; i++)
-                indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
+            for (uint256 i = 0; i < tokens.length; i++) indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
         } else {
             indexes = IStandardizedYield(SY).rewardIndexesCurrent();
         }

package/contracts/core/YieldContractsV2/InterestManagerYTV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";
@@ -44,27 +44,18 @@ abstract contract InterestManagerYTV2 is TokenHelper, IPInterestManagerYTV2 {
     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);
+        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) {
+    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 {
+    function _distributeInterestPrivate(address user, uint256 currentIndex, uint256 pyIndex) private {
         assert(user != address(0) && user != address(this));
 
         uint256 prevIndex = userInterest[user].index;

package/contracts/core/YieldContractsV2/PendlePrincipalTokenV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";

package/contracts/core/YieldContractsV2/PendleYieldContractFactoryV2.sol

@@ -21,7 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  */
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPYieldContractFactory.sol";
 
@@ -106,8 +106,7 @@ contract PendleYieldContractFactoryV2 is BoringOwnableUpgradeable, IPYieldContra
         uint32 expiry,
         bool doCacheIndexSameBlock
     ) external returns (address PT, address YT) {
-        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
-            revert Errors.YCFactoryInvalidExpiry();
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0) revert Errors.YCFactoryInvalidExpiry();
 
         if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
 

package/contracts/core/YieldContractsV2/PendleYieldTokenV2.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/token/ERC20/utils/SafeERC20.sol";
 
@@ -23,12 +23,7 @@ Invariance to maintain:
 - address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
     guaranteed by address(0) & address(this) check in each updateForTwo function
 */
-contract PendleYieldTokenV2 is
-    IPYieldTokenV2,
-    PendleERC20Permit,
-    RewardManager,
-    InterestManagerYTV2
-{
+contract PendleYieldTokenV2 is IPYieldTokenV2, PendleERC20Permit, RewardManager, InterestManagerYTV2 {
     using PMath for uint256;
     using SafeERC20 for IERC20;
     using ArrayLib for uint256[];
@@ -97,11 +92,7 @@ contract PendleYieldTokenV2 is
         address[] memory receiverYTs = new address[](1);
         uint256[] memory amountSyToMints = new uint256[](1);
 
-        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
-            receiverPT,
-            receiverYT,
-            _getFloatingSyAmount()
-        );
+        (receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (receiverPT, receiverYT, _getFloatingSyAmount());
 
         uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
         amountPYOut = amountPYOuts[0];
@@ -116,8 +107,7 @@ contract PendleYieldTokenV2 is
         uint256 length = receiverPTs.length;
 
         if (length == 0) revert Errors.ArrayEmpty();
-        if (receiverYTs.length != length || amountSyToMints.length != length)
-            revert Errors.ArrayLengthMismatch();
+        if (receiverYTs.length != length || amountSyToMints.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalSyToMint = amountSyToMints.sum();
         if (totalSyToMint > _getFloatingSyAmount())
@@ -131,9 +121,7 @@ contract PendleYieldTokenV2 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());
@@ -264,13 +252,7 @@ contract PendleYieldTokenV2 is
             _mint(receiverYTs[i], amountPYOuts[i]);
             IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
 
-            emit Mint(
-                msg.sender,
-                receiverPTs[i],
-                receiverYTs[i],
-                amountSyToMints[i],
-                amountPYOuts[i]
-            );
+            emit Mint(msg.sender, receiverPTs[i], receiverYTs[i], amountSyToMints[i], amountPYOuts[i]);
         }
     }
 
@@ -296,10 +278,7 @@ contract PendleYieldTokenV2 is
 
         for (uint256 i = 0; i < receivers.length; i++) {
             uint256 syInterestPostExpiry;
-            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
-                amountPYToRedeems[i],
-                index
-            );
+            (amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(amountPYToRedeems[i], index);
             _transferOut(SY, receivers[i], amountSyOuts[i]);
             totalSyInterestPostExpiry += syInterestPostExpiry;
 
@@ -310,10 +289,7 @@ contract PendleYieldTokenV2 is
         _transferOut(SY, treasury, totalSyInterestPostExpiry);
     }
 
-    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);
     }
@@ -359,23 +335,16 @@ contract PendleYieldTokenV2 is
     //////////////////////////////////////////////////////////////*/
 
     function _pyIndexCurrent() internal returns (uint256 currentIndex) {
-        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
-            return _pyIndexStored;
+        if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number) return _pyIndexStored;
 
-        uint128 index128 = PMath
-            .max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
-            .Uint128();
+        uint128 index128 = PMath.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored).Uint128();
 
         currentIndex = index128;
         _pyIndexStored = index128;
         pyIndexLastUpdatedBlock = uint128(block.number);
     }
 
-    function _collectInterest()
-        internal
-        override
-        returns (uint256 accuredAmount, uint256 currentIndex)
-    {
+    function _collectInterest() internal override returns (uint256 accruedAmount, uint256 currentIndex) {
         uint256 prevIndex = _lastCollectedInterestIndex;
         currentIndex = _pyIndexCurrent();
 
@@ -388,7 +357,7 @@ contract PendleYieldTokenV2 is
 
             uint256 totalInterest = _calcInterest(totalSupply(), prevIndex, currentIndex);
             uint256 feeAmount = totalInterest.mulDown(interestFeeRate);
-            accuredAmount = totalInterest - feeAmount;
+            accruedAmount = totalInterest - feeAmount;
 
             _transferOut(SY, treasury, feeAmount);
             _updateSyReserve();
@@ -398,11 +367,7 @@ contract PendleYieldTokenV2 is
         _lastCollectedInterestIndex = currentIndex;
     }
 
-    function _calcInterest(
-        uint256 principal,
-        uint256 prevIndex,
-        uint256 currentIndex
-    ) internal pure returns (uint256) {
+    function _calcInterest(uint256 principal, uint256 prevIndex, uint256 currentIndex) internal pure returns (uint256) {
         return (principal * (currentIndex - prevIndex)).divDown(prevIndex * currentIndex);
     }
 

package/contracts/core/erc20/PendleERC20.sol

@@ -103,10 +103,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
      * - `to` cannot be the zero address.
      * - the caller must have a balance of at least `amount`.
      */
-    function transfer(
-        address to,
-        uint256 amount
-    ) external virtual override nonReentrant returns (bool) {
+    function transfer(address to, uint256 amount) external virtual override nonReentrant returns (bool) {
         address owner = _msgSender();
         _transfer(owner, to, amount);
         return true;
@@ -115,10 +112,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     /**
      * @dev See {IERC20-allowance}.
      */
-    function allowance(
-        address owner,
-        address spender
-    ) public view virtual override returns (uint256) {
+    function allowance(address owner, address spender) public view virtual override returns (uint256) {
         return _allowances[owner][spender];
     }
 

package/contracts/core/erc20/PendleERC20Permit.sol

@@ -20,9 +20,7 @@ contract PendleERC20Permit is PendleERC20, IERC20Permit, EIP712 {
 
     // solhint-disable-next-line var-name-mixedcase
     bytes32 private constant _PERMIT_TYPEHASH =
-        keccak256(
-            "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
-        );
+        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
 
     constructor(
         string memory name_,
@@ -44,9 +42,7 @@ contract PendleERC20Permit is PendleERC20, IERC20Permit, EIP712 {
     ) public virtual override {
         require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
 
-        bytes32 structHash = keccak256(
-            abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline)
-        );
+        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
 
         bytes32 hash = _hashTypedDataV4(structHash);
 

package/contracts/core/erc20/PendleERC20PermitUpg.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
+
+pragma solidity ^0.8.0;
+
+import "./PendleERC20Upg.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import "@openzeppelin/contracts/utils/Context.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "@openzeppelin/contracts/utils/Counters.sol";
+
+/// @dev forked from OZ's ERC20Permit
+abstract contract PendleERC20PermitUpg is PendleERC20Upg, IERC20Permit, EIP712Upgradeable {
+    using Counters for Counters.Counter;
+
+    mapping(address => Counters.Counter) private _nonces;
+
+    uint256[100] private __gap;
+
+    // solhint-disable-next-line var-name-mixedcase
+    bytes32 private constant _PERMIT_TYPEHASH =
+        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+
+    function __ERC20PermitUpg_init(string memory name_, string memory symbol_) internal onlyInitializing {
+        __ERC20Upg_init(name_, symbol_);
+        __EIP712_init(name_, "1");
+    }
+
+    /**
+     * @dev See {IERC20Permit-permit}.
+     */
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public virtual override {
+        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
+
+        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
+
+        bytes32 hash = _hashTypedDataV4(structHash);
+
+        address signer = ECDSA.recover(hash, v, r, s);
+        require(signer == owner, "ERC20Permit: invalid signature");
+
+        _approve(owner, spender, value);
+    }
+
+    /**
+     * @dev See {IERC20Permit-nonces}.
+     */
+    function nonces(address owner) public view virtual override returns (uint256) {
+        return _nonces[owner].current();
+    }
+
+    /**
+     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
+     */
+    // solhint-disable-next-line func-name-mixedcase
+    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
+        return _domainSeparatorV4();
+    }
+
+    /**
+     * @dev "Consume a nonce": return the current value and increment.
+     *
+     * _Available since v4.1._
+     */
+    function _useNonce(address owner) internal virtual returns (uint256 current) {
+        Counters.Counter storage nonce = _nonces[owner];
+        current = nonce.current();
+        nonce.increment();
+    }
+}