@pendle/core-v2 0.7.1-beta → 0.8.0-beta

package/contracts/core/Market/PendleMarket.sol

@@ -1,24 +1,27 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
+import "../PendleERC20.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/ISuperComposableYield.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
-import "../../interfaces/IPMarketAddRemoveCallback.sol";
 
 import "../../libraries/math/LogExpMath.sol";
 import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 
 import "../LiquidityMining/PendleGauge.sol";
-import "../PendleERC20.sol";
+import "../PendleERC20Permit.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
-// solhint-disable reason-string
-/// Invariances to maintain:
-/// - Internal balances totalPt & totalScy not interferred by people transferring tokens in directly
+/**
+Invariances to maintain:
+- Internal balances totalPt & totalScy not interferred by people transferring tokens in directly
+- 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 PendleMarket is PendleERC20, PendleGauge, IPMarket {
     using Math for uint256;
     using Math for int256;
@@ -36,9 +39,6 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         // 1 SLOT = 224 bits
     }
 
-    uint8 private constant _NOT_ENTERED = 1;
-    uint8 private constant _ENTERED = 2;
-
     string private constant NAME = "Pendle Market";
     string private constant SYMBOL = "PENDLE-LPT";
 
@@ -81,29 +81,24 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
     /**
      * @notice PendleMarket allows users to provide in PT & SCY in exchange for LPs, which
-     * will grant LP holders more exchange fee over time. All the tokens must be transferred to
-     * this market prior to the call for LP to be minted. There is no flashAdd
-     * @param data bytes data to be sent in the callback
+     * will grant LP holders more exchange fee over time
      */
-    function addLiquidity(
-        address receiver,
-        uint256 scyDesired,
-        uint256 ptDesired,
-        bytes calldata data
-    )
+    function mint(address receiver)
         external
         nonReentrant
         notExpired
-        returns (
-            uint256 lpToAccount,
-            uint256 scyUsed,
-            uint256 ptUsed
-        )
+        returns (uint256 lpToAccount)
     {
         MarketState memory market = readState(true);
         SCYIndex index = SCY.newIndex();
 
+        uint256 scyDesired = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
+        uint256 ptDesired = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
+
         uint256 lpToReserve;
+        uint256 scyUsed;
+        uint256 ptUsed;
+
         (lpToReserve, lpToAccount, scyUsed, ptUsed) = market.addLiquidity(
             index,
             scyDesired,
@@ -121,39 +116,23 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)));
-        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
-
-        emit AddLiquidity(receiver, lpToAccount, scyUsed, ptUsed);
-
-        // no flashAdd, we only do callback after all the tokens have been provided
-        if (data.length > 0) {
-            IPMarketAddRemoveCallback(msg.sender).addLiquidityCallback(
-                lpToAccount,
-                scyUsed,
-                ptUsed,
-                data
-            );
-        }
+        emit Mint(receiver, lpToAccount, scyUsed, ptUsed);
     }
 
     /**
      * @notice LP Holders can burn their LP to receive back SCY & PT proportionally
      * to their share of market
-     * @dev steps working of this contract
-       - SCY & PT will be first transferred out to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure the corresponding amount of LP has been transferred to this contract
-     * @param data bytes data to be sent in the callback
      */
-    function removeLiquidity(
-        address receiverScy,
-        address receiverPt,
-        uint256 lpToRemove,
-        bytes calldata data
-    ) external nonReentrant returns (uint256 scyToAccount, uint256 ptToAccount) {
+    function burn(address receiverScy, address receiverPt)
+        external
+        nonReentrant
+        returns (uint256 scyToAccount, uint256 ptToAccount)
+    {
         MarketState memory market = readState(true);
 
+        uint256 lpToRemove = balanceOf(address(this));
+        _burn(address(this), lpToRemove);
+
         (scyToAccount, ptToAccount) = market.removeLiquidity(lpToRemove, true);
 
         IERC20(SCY).safeTransfer(receiverScy, scyToAccount);
@@ -161,19 +140,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        if (data.length > 0) {
-            IPMarketAddRemoveCallback(msg.sender).removeLiquidityCallback(
-                lpToRemove,
-                scyToAccount,
-                ptToAccount,
-                data
-            );
-        }
-
-        // this checks enough lp has been transferred in
-        _burn(address(this), lpToRemove);
-
-        emit RemoveLiquidity(receiverScy, receiverPt, lpToRemove, scyToAccount, ptToAccount);
+        emit Burn(receiverScy, receiverPt, lpToRemove, scyToAccount, ptToAccount);
     }
 
     /**
@@ -209,7 +176,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         }
 
         // have received enough PT
-        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)));
+        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)), "insufficient PT");
 
         emit Swap(receiver, exactPtIn.neg(), netScyOut.Int(), netScyToReserve);
     }
@@ -246,7 +213,10 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         }
 
         // have received enough SCY
-        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
+        require(
+            market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)),
+            "insufficient SCY"
+        );
 
         emit Swap(receiver, exactPtOut.Int(), netScyIn.neg(), netScyToReserve);
     }

package/contracts/core/PendleRouter.sol

@@ -56,7 +56,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg
             sig == IPActionCore.swapExactScyForPt.selector ||
             sig == IPActionCore.swapExactRawTokenForPt.selector ||
             sig == IPActionCore.swapExactPtForRawToken.selector ||
-            sig == IPActionCore.redeemDueIncome.selector
+            sig == IPActionCore.redeemDueInterestAndRewards.selector
         ) {
             return ACTION_CORE;
         } else if (

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -37,10 +37,11 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
     }
 
     function _distributeInterestForTwo(address user1, address user2) internal {
-        // no updateRewardIndex since we rely on SCY's rewardIndexes
         uint256 index = _getInterestIndex();
-        if (user1 != address(0) && user1 != address(this)) _distributeInterest(user1, index);
-        if (user2 != address(0) && user2 != address(this)) _distributeInterest(user2, index);
+        if (user1 != address(0) && user1 != address(this))
+            _distributeInterestPrivate(user1, index);
+        if (user2 != address(0) && user2 != address(this))
+            _distributeInterestPrivate(user2, index);
     }
 
     function _doTransferOutInterest(
@@ -48,13 +49,12 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
         address SCY,
         address factory
     ) internal returns (uint256 interestAmount) {
-        uint256 interestPreFee = userInterest[user].accrued;
-        userInterest[user].accrued = 0;
-
         address treasury = IPYieldContractFactory(factory).treasury();
-
         uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
 
+        uint256 interestPreFee = userInterest[user].accrued;
+        userInterest[user].accrued = 0;
+
         uint256 feeAmount = interestPreFee.mulDown(feeRate);
         interestAmount = interestPreFee - feeAmount;
 
@@ -62,7 +62,10 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
         _transferOut(SCY, user, interestAmount);
     }
 
-    function _distributeInterest(address user, uint256 currentIndex) private {
+    // should only be callable from `_distributeInterestForTwo` & make sure user != address(0) && user != address(this)
+    function _distributeInterestPrivate(address user, uint256 currentIndex) private {
+        assert(user != address(0) && user != address(this));
+
         uint256 prevIndex = userInterest[user].index;
 
         if (prevIndex == currentIndex) return;

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,11 +4,11 @@ pragma solidity 0.8.15;
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 
-import "../PendleERC20.sol";
+import "../PendleERC20Permit.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
     address public immutable SCY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -30,7 +30,7 @@ contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20(_name, _symbol, __decimals) {
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
         SCY = _SCY;
         expiry = _expiry;
         factory = msg.sender;

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -46,13 +46,13 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
 
     address public pendleYtCreationCodePointer;
 
-    uint256 public expiryDivisor;
-    uint256 public interestFeeRate;
-    address public treasury;
+    // 1 SLOT
+    uint128 public interestFeeRate; // a fixed point number
+    uint128 public rewardFeeRate; // a fixed point number
 
-    /// number of contracts that have been deployed from this address
-    /// must be increased everytime a new contract is deployed
-    uint256 public numContractDeployed;
+    // 1 SLOT
+    address public treasury;
+    uint96 public expiryDivisor;
 
     // SCY => expiry => address
     mapping(address => mapping(uint256 => address)) public getPT;
@@ -61,15 +61,16 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
     mapping(address => bool) public isYT;
 
     constructor(
-        uint256 _expiryDivisor,
-        uint256 _interestFeeRate,
+        uint96 _expiryDivisor,
+        uint128 _interestFeeRate,
+        uint128 _rewardFeeRate,
         address _treasury,
         address _governanceManager
     ) PermissionsV2Upg(_governanceManager) {
         setExpiryDivisor(_expiryDivisor);
         setInterestFeeRate(_interestFeeRate);
+        setRewardFeeRate(_rewardFeeRate);
         setTreasury(_treasury);
-        numContractDeployed++;
     }
 
     function initialize(bytes memory _pendleYtCreationCode) external initializer {
@@ -130,20 +131,25 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
         emit CreateYieldContract(SCY, PT, YT, expiry);
     }
 
-    function setExpiryDivisor(uint256 newExpiryDivisor) public onlyGovernance {
+    function setExpiryDivisor(uint96 newExpiryDivisor) public onlyGovernance {
         require(newExpiryDivisor != 0, "zero value");
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
 
-    function setInterestFeeRate(uint256 newInterestFeeRate) public onlyGovernance {
+    function setInterestFeeRate(uint128 newInterestFeeRate) public onlyGovernance {
         interestFeeRate = newInterestFeeRate;
         emit SetInterestFeeRate(newInterestFeeRate);
     }
 
+    function setRewardFeeRate(uint128 newInterestFeeRate) public onlyGovernance {
+        rewardFeeRate = newInterestFeeRate;
+        emit SetInterestFeeRate(newInterestFeeRate);
+    }
+
     function setTreasury(address newTreasury) public onlyGovernance {
         require(newTreasury != address(0), "zero address");
         treasury = newTreasury;
-        emit SetTreasury(treasury);
+        emit SetTreasury(newTreasury);
     }
 }