@pendle/core-v2 0.6.9 → 0.7.0

package/contracts/core/{PendleMarket.sol → Market/PendleMarket.sol}

@@ -1,29 +1,31 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
-
-import "./PendleBaseToken.sol";
-import "../interfaces/IPPrincipalToken.sol";
-import "../SuperComposableYield/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/math/MarketMathAux.sol";
-
+pragma solidity 0.8.13;
+
+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 "../PendleERC20Permit.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 // solhint-disable reason-string
-contract PendleMarket is PendleBaseToken, IPMarket {
+/// Invariances to maintain:
+/// - Internal balances totalPt & totalScy not interferred by people transferring tokens in directly
+contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     using Math for uint256;
     using Math for int256;
-    using Math for uint128;
-    using LogExpMath for uint256;
-    using MarketMathAux for MarketState;
     using MarketMathCore for MarketState;
     using SafeERC20 for IERC20;
+    using SCYIndexLib for ISuperComposableYield;
 
     struct MarketStorage {
         int128 totalPt;
@@ -32,8 +34,7 @@ contract PendleMarket is PendleBaseToken, IPMarket {
         uint96 lastLnImpliedRate;
         uint96 oracleRate;
         uint32 lastTradeTime;
-        uint8 _reentrancyStatus;
-        // 1 SLOT = 232 bits
+        // 1 SLOT = 224 bits
     }
 
     uint8 private constant _NOT_ENTERED = 1;
@@ -42,49 +43,47 @@ contract PendleMarket is PendleBaseToken, IPMarket {
     string private constant NAME = "Pendle Market";
     string private constant SYMBOL = "PENDLE-LPT";
 
-    address public immutable PT;
-    address public immutable SCY;
-    address public immutable YT;
+    IPPrincipalToken internal immutable PT;
+    ISuperComposableYield internal immutable SCY;
+    IPYieldToken internal immutable YT;
 
+    address public immutable factory;
+    uint256 public immutable expiry;
     int256 public immutable scalarRoot;
     int256 public immutable initialAnchor;
 
     MarketStorage public _storage;
 
-    modifier nonReentrant() {
-        // On the first call to nonReentrant, _notEntered will be true
-        require(_storage._reentrancyStatus != _ENTERED, "ReentrancyGuard: reentrant call");
-
-        // Any calls to nonReentrant after this point will fail
-        _storage._reentrancyStatus = _ENTERED;
-
+    modifier notExpired() {
+        require(!isExpired(), "market expired");
         _;
-
-        // By storing the original value once again, a refund is triggered (see
-        // https://eips.ethereum.org/EIPS/eip-2200)
-        _storage._reentrancyStatus = _NOT_ENTERED;
     }
 
     constructor(
         address _PT,
         int256 _scalarRoot,
-        int256 _initialAnchor
-    ) PendleBaseToken(NAME, SYMBOL, 18, IPPrincipalToken(_PT).expiry()) {
-        PT = _PT;
-        SCY = IPPrincipalToken(_PT).SCY();
-        YT = IPPrincipalToken(_PT).YT();
+        int256 _initialAnchor,
+        address _vePendle,
+        address _gaugeController
+    )
+        PendleERC20Permit(NAME, SYMBOL, 18)
+        PendleGauge(IPPrincipalToken(_PT).SCY(), _vePendle, _gaugeController)
+    {
+        PT = IPPrincipalToken(_PT);
+        SCY = ISuperComposableYield(PT.SCY());
+        YT = IPYieldToken(PT.YT());
+
+        require(_scalarRoot > 0, "scalarRoot must be positive");
         scalarRoot = _scalarRoot;
         initialAnchor = _initialAnchor;
-        _storage._reentrancyStatus = _NOT_ENTERED;
+        expiry = IPPrincipalToken(_PT).expiry();
+        factory = msg.sender;
     }
 
     /**
      * @notice PendleMarket allows users to provide in PT & SCY in exchange for LPs, which
-     * will grant LP holders more exchange fee over time
-     * @dev steps working of this function:
-       - Releases the proportional amount of LP to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure that the corresponding amount of SCY & PT have been transferred to this address
+     * 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
      */
     function addLiquidity(
@@ -95,6 +94,7 @@ contract PendleMarket is PendleBaseToken, IPMarket {
     )
         external
         nonReentrant
+        notExpired
         returns (
             uint256 lpToAccount,
             uint256 scyUsed,
@@ -102,7 +102,7 @@ contract PendleMarket is PendleBaseToken, IPMarket {
         )
     {
         MarketState memory market = readState(true);
-        SCYIndex index = SCYIndexLib.newIndex(SCY);
+        SCYIndex index = SCY.newIndex();
 
         uint256 lpToReserve;
         (lpToReserve, lpToAccount, scyUsed, ptUsed) = market.addLiquidity(
@@ -120,6 +120,14 @@ contract PendleMarket is PendleBaseToken, IPMarket {
 
         _mint(receiver, lpToAccount);
 
+        _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,
@@ -128,13 +136,6 @@ contract PendleMarket is PendleBaseToken, IPMarket {
                 data
             );
         }
-
-        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)));
-        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
-
-        _writeState(market);
-
-        emit AddLiquidity(receiver, lpToAccount, scyUsed, ptUsed);
     }
 
     /**
@@ -147,7 +148,8 @@ contract PendleMarket is PendleBaseToken, IPMarket {
      * @param data bytes data to be sent in the callback
      */
     function removeLiquidity(
-        address receiver,
+        address receiverScy,
+        address receiverPt,
         uint256 lpToRemove,
         bytes calldata data
     ) external nonReentrant returns (uint256 scyToAccount, uint256 ptToAccount) {
@@ -155,8 +157,10 @@ contract PendleMarket is PendleBaseToken, IPMarket {
 
         (scyToAccount, ptToAccount) = market.removeLiquidity(lpToRemove, true);
 
-        IERC20(SCY).safeTransfer(receiver, scyToAccount);
-        IERC20(PT).safeTransfer(receiver, ptToAccount);
+        IERC20(SCY).safeTransfer(receiverScy, scyToAccount);
+        IERC20(PT).safeTransfer(receiverPt, ptToAccount);
+
+        _writeState(market);
 
         if (data.length > 0) {
             IPMarketAddRemoveCallback(msg.sender).removeLiquidityCallback(
@@ -167,10 +171,10 @@ contract PendleMarket is PendleBaseToken, IPMarket {
             );
         }
 
+        // this checks enough lp has been transferred in
         _burn(address(this), lpToRemove);
 
-        _writeState(market);
-        emit RemoveLiquidity(receiver, lpToRemove, scyToAccount, ptToAccount);
+        emit RemoveLiquidity(receiverScy, receiverPt, lpToRemove, scyToAccount, ptToAccount);
     }
 
     /**
@@ -186,31 +190,27 @@ contract PendleMarket is PendleBaseToken, IPMarket {
     function swapExactPtForScy(
         address receiver,
         uint256 exactPtIn,
-        uint256 minScyOut,
         bytes calldata data
-    ) external nonReentrant returns (uint256 netScyOut, uint256 netScyToReserve) {
-        require(block.timestamp < expiry, "MARKET_EXPIRED");
-
+    ) external nonReentrant notExpired returns (uint256 netScyOut, uint256 netScyToReserve) {
         MarketState memory market = readState(true);
 
         (netScyOut, netScyToReserve) = market.swapExactPtForScy(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             exactPtIn,
-            block.timestamp,
-            true
+            block.timestamp
         );
-        require(netScyOut >= minScyOut, "insufficient scy out");
 
         IERC20(SCY).safeTransfer(receiver, netScyOut);
         IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
+        _writeState(market);
+
         if (data.length > 0) {
             IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netScyOut.Int(), data);
         }
 
         // have received enough PT
         require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)));
-        _writeState(market);
 
         emit Swap(receiver, exactPtIn.neg(), netScyOut.Int(), netScyToReserve);
     }
@@ -227,44 +227,46 @@ contract PendleMarket is PendleBaseToken, IPMarket {
     function swapScyForExactPt(
         address receiver,
         uint256 exactPtOut,
-        uint256 maxScyIn,
         bytes calldata data
-    ) external nonReentrant returns (uint256 netScyIn, uint256 netScyToReserve) {
-        require(block.timestamp < expiry, "MARKET_EXPIRED");
-
+    ) external nonReentrant notExpired returns (uint256 netScyIn, uint256 netScyToReserve) {
         MarketState memory market = readState(true);
 
         (netScyIn, netScyToReserve) = market.swapScyForExactPt(
-            SCYIndexLib.newIndex(SCY),
+            SCY.newIndex(),
             exactPtOut,
-            block.timestamp,
-            true
+            block.timestamp
         );
-        require(netScyIn <= maxScyIn, "scy in exceed limit");
 
         IERC20(PT).safeTransfer(receiver, exactPtOut);
         IERC20(SCY).safeTransfer(market.treasury, netScyToReserve);
 
+        _writeState(market);
+
         if (data.length > 0) {
             IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netScyIn.neg(), data);
         }
 
         // have received enough SCY
         require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
-        _writeState(market);
 
         emit Swap(receiver, exactPtOut.Int(), netScyIn.neg(), netScyToReserve);
     }
 
-    /// @dev this function is just a place holder. Later on the rewards will be transferred to the liquidity minining
-    /// instead
-    function redeemScyReward() external returns (uint256[] memory outAmounts) {
-        outAmounts = ISuperComposableYield(SCY).redeemReward(address(this));
-        address[] memory rewardTokens = ISuperComposableYield(SCY).getRewardTokens();
-        address treasury = IPMarketFactory(factory).treasury();
-        for (uint256 i = 0; i < rewardTokens.length; i++) {
-            IERC20(rewardTokens[i]).safeTransfer(treasury, outAmounts[i]);
-        }
+    /// @notice force balances to match reserves
+    function skim() external nonReentrant {
+        MarketState memory market = readState(true);
+        uint256 excessPt = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
+        uint256 excessScy = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
+        IERC20(PT).safeTransfer(market.treasury, excessPt);
+        IERC20(SCY).safeTransfer(market.treasury, excessScy);
+    }
+
+    function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
+        return _redeemRewards(user);
+    }
+
+    function getRewardTokens() external view returns (address[] memory) {
+        return _getRewardTokens();
     }
 
     function readTokens()
@@ -276,18 +278,25 @@ contract PendleMarket is PendleBaseToken, IPMarket {
             IPYieldToken _YT
         )
     {
-        _SCY = ISuperComposableYield(SCY);
-        _PT = IPPrincipalToken(PT);
-        _YT = IPYieldToken(YT);
+        _SCY = SCY;
+        _PT = PT;
+        _YT = YT;
     }
 
-    function readState(bool updateRateOracle) public view returns (MarketState memory market) {
-        MarketStorage memory local = _storage;
+    function isExpired() public view returns (bool) {
+        return MiniHelpers.isCurrentlyExpired(expiry);
+    }
 
-        market.totalPt = local.totalPt;
-        market.totalScy = local.totalScy;
+    /**
+     * @notice read the state of the market from storage into memory for gas-efficient manipulation
+     * @param updateRateOracle if set to true, the oracleRate will be updated, which will take ~6k of gas. If router wants
+        to do external calculations, normally this can be set to false
+     */
+    function readState(bool updateRateOracle) public view returns (MarketState memory market) {
+        market.totalPt = _storage.totalPt;
+        market.totalScy = _storage.totalScy;
         market.totalLp = totalSupply().Int();
-        market.oracleRate = local.oracleRate;
+        market.oracleRate = _storage.oracleRate;
 
         (
             market.treasury,
@@ -299,25 +308,52 @@ contract PendleMarket is PendleBaseToken, IPMarket {
         market.scalarRoot = scalarRoot;
         market.expiry = expiry;
 
-        market.lastLnImpliedRate = local.lastLnImpliedRate;
-        market.lastTradeTime = local.lastTradeTime;
+        market.lastLnImpliedRate = _storage.lastLnImpliedRate;
+        market.lastTradeTime = _storage.lastTradeTime;
 
         if (updateRateOracle) {
+            // must happen after lastLnImpliedRate & lastTradeTime is filled
             market.oracleRate = market.getNewRateOracle(block.timestamp);
         }
     }
 
+    /// @notice write back the state of the market from memory to storage
     function _writeState(MarketState memory market) internal {
-        MarketStorage memory tempStore;
+        _storage.totalPt = market.totalPt.Int128();
+        _storage.totalScy = market.totalScy.Int128();
+        _storage.lastLnImpliedRate = market.lastLnImpliedRate.Uint96();
+        _storage.oracleRate = market.oracleRate.Uint96();
+        _storage.lastTradeTime = market.lastTradeTime.Uint32();
+        emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
+    }
 
-        tempStore.totalPt = market.totalPt.Int128();
-        tempStore.totalScy = market.totalScy.Int128();
-        tempStore.lastLnImpliedRate = market.lastLnImpliedRate.Uint96();
-        tempStore.oracleRate = market.oracleRate.Uint96();
-        tempStore.lastTradeTime = market.lastTradeTime.Uint32();
+    /*///////////////////////////////////////////////////////////////
+                    PENDLE GAUGE - RELATED
+    //////////////////////////////////////////////////////////////*/
 
-        _storage = tempStore;
+    function _stakedBalance(address user) internal view override returns (uint256) {
+        return balanceOf(user);
+    }
 
-        emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
+    function _totalStaked() internal view override returns (uint256) {
+        return totalSupply();
+    }
+
+    // solhint-disable-next-line ordering
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override(PendleERC20, PendleGauge) {
+        PendleGauge._beforeTokenTransfer(from, to, amount);
+    }
+
+    // solhint-disable-next-line ordering
+    function _afterTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override(PendleERC20, PendleGauge) {
+        PendleGauge._afterTokenTransfer(from, to, amount);
     }
 }

package/contracts/core/{PendleMarketFactory.sol → Market/PendleMarketFactory.sol}

@@ -1,13 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.9;
+pragma solidity 0.8.13;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-import "../interfaces/IPMarket.sol";
-import "../interfaces/IPYieldContractFactory.sol";
-import "../interfaces/IPMarketFactory.sol";
-import "../periphery/PermissionsV2Upg.sol";
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+
+import "../../interfaces/IPMarket.sol";
+import "../../interfaces/IPYieldContractFactory.sol";
+import "../../interfaces/IPMarketFactory.sol";
+
+import "../../libraries/helpers/MiniDeployer.sol";
+import "../../periphery/PermissionsV2Upg.sol";
+
 import "./PendleMarket.sol";
+import "../LiquidityMining/PendleGauge.sol";
 
-contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
+contract PendleMarketFactory is PermissionsV2Upg, MiniDeployer, Initializable, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
     struct MarketConfig {
@@ -19,11 +25,18 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
         // 1 SLOT = 40 bits
     }
 
-    mapping(address => EnumerableSet.AddressSet) internal markets;
+    uint256 private constant MIN_RATE_ORACLE_TIME_WINDOW = 300 seconds;
 
     address public immutable yieldContractFactory;
+    address public immutable marketCreationCodePointer;
     uint256 public immutable maxLnFeeRateRoot;
-    uint256 public constant minRateOracleTimeWindow = 300 seconds;
+
+    // PT -> scalarRoot -> initialAnchor
+    mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
+    EnumerableSet.AddressSet internal allMarkets;
+
+    address public vePendle;
+    address public gaugeController;
 
     MarketConfig public marketConfig;
 
@@ -33,7 +46,8 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
         address _treasury,
         uint96 _lnFeeRateRoot,
         uint32 _rateOracleTimeWindow,
-        uint8 _reserveFeePercent
+        uint8 _reserveFeePercent,
+        bytes memory _marketCreationCode
     ) PermissionsV2Upg(_governanceManager) {
         require(_yieldContractFactory != address(0), "zero address");
         yieldContractFactory = _yieldContractFactory;
@@ -43,6 +57,17 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
         setlnFeeRateRoot(_lnFeeRateRoot);
         setRateOracleTimeWindow(_rateOracleTimeWindow);
         setReserveFeePercent(_reserveFeePercent);
+        marketCreationCodePointer = _setCreationCode(_marketCreationCode);
+    }
+
+    function initialize(address newVePendle, address newGaugeController)
+        external
+        onlyGovernance
+        initializer
+    {
+        require(newVePendle != address(0) && newGaugeController != address(0), "zero address");
+        vePendle = newVePendle;
+        gaugeController = newGaugeController;
     }
 
     /**
@@ -54,23 +79,27 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
         int256 scalarRoot,
         int256 initialAnchor
     ) external returns (address market) {
-        address SCY = IPPrincipalToken(PT).SCY();
-        uint256 expiry = IPPrincipalToken(PT).expiry();
-
+        require(IPYieldContractFactory(yieldContractFactory).isPT(PT), "Invalid PT");
+        require(vePendle != address(0), "vePendle unset");
+        require(gaugeController != address(0), "gaugeController unset");
         require(
-            IPYieldContractFactory(yieldContractFactory).getPT(SCY, expiry) == PT,
-            "INVALID_PT"
+            markets[PT][scalarRoot][initialAnchor] == address(0),
+            "duplicated creation params"
+        );
+
+        market = _deployWithArgs(
+            marketCreationCodePointer,
+            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController)
         );
 
-        market = address(new PendleMarket(PT, scalarRoot, initialAnchor));
-        require(markets[PT].add(market), "market add failed");
+        markets[PT][scalarRoot][initialAnchor] = market;
+        require(allMarkets.add(market), "IE market can't be added");
 
         emit CreateNewMarket(PT, scalarRoot, initialAnchor);
     }
 
     function isValidMarket(address market) external view returns (bool) {
-        address PT = IPMarket(market).PT();
-        return markets[PT].contains(market);
+        return allMarkets.contains(market);
     }
 
     function treasury() external view returns (address) {
@@ -80,20 +109,34 @@ contract PendleMarketFactory is PermissionsV2Upg, IPMarketFactory {
     function setTreasury(address newTreasury) public onlyGovernance {
         require(newTreasury != address(0), "zero address");
         marketConfig.treasury = newTreasury;
+        _emitNewMarketConfigEvent();
     }
 
     function setlnFeeRateRoot(uint96 newlnFeeRateRoot) public onlyGovernance {
         require(newlnFeeRateRoot <= maxLnFeeRateRoot, "invalid fee rate root");
         marketConfig.lnFeeRateRoot = newlnFeeRateRoot;
+        _emitNewMarketConfigEvent();
     }
 
     function setRateOracleTimeWindow(uint32 newRateOracleTimeWindow) public onlyGovernance {
-        require(newRateOracleTimeWindow >= minRateOracleTimeWindow, "invalid time window");
+        require(newRateOracleTimeWindow >= MIN_RATE_ORACLE_TIME_WINDOW, "invalid time window");
         marketConfig.rateOracleTimeWindow = newRateOracleTimeWindow;
+        _emitNewMarketConfigEvent();
     }
 
     function setReserveFeePercent(uint8 newReserveFeePercent) public onlyGovernance {
         require(newReserveFeePercent <= 100, "invalid reserve fee percent");
         marketConfig.reserveFeePercent = newReserveFeePercent;
+        _emitNewMarketConfigEvent();
+    }
+
+    function _emitNewMarketConfigEvent() internal {
+        MarketConfig memory local = marketConfig;
+        emit NewMarketConfig(
+            local.treasury,
+            local.lnFeeRateRoot,
+            local.rateOracleTimeWindow,
+            local.reserveFeePercent
+        );
     }
 }