@pendle/core-v2 0.11.11-testnet → 0.12.0-testnet

package/contracts/core/Market/PendleMarket.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "../PendleERC20.sol";
+import "../PendleERC20Permit.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/ISuperComposableYield.sol";
 import "../../interfaces/IPMarket.sol";
@@ -12,6 +12,7 @@ import "../../libraries/OracleLib.sol";
 import "../../libraries/math/LogExpMath.sol";
 import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
+import "../../libraries/Errors.sol";
 
 import "../LiquidityMining/PendleGauge.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -22,7 +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 PendleMarket is PendleERC20, PendleGauge, IPMarket {
+contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -58,7 +59,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     OracleLib.Observation[65535] public observations;
 
     modifier notExpired() {
-        require(!isExpired(), "market expired");
+        if (isExpired()) revert Errors.MarketExpired();
         _;
     }
 
@@ -69,7 +70,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         address _vePendle,
         address _gaugeController
     )
-        PendleERC20(NAME, SYMBOL, 18)
+        PendleERC20Permit(NAME, SYMBOL, 18)
         PendleGauge(IPPrincipalToken(_PT).SCY(), _vePendle, _gaugeController)
     {
         PT = IPPrincipalToken(_PT);
@@ -79,7 +80,8 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         (_storage.observationCardinality, _storage.observationCardinalityNext) = observations
             .initialize(uint32(block.timestamp));
 
-        require(_scalarRoot > 0, "scalarRoot must be positive");
+        if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
+
         scalarRoot = _scalarRoot;
         initialAnchor = _initialAnchor;
         expiry = IPPrincipalToken(_PT).expiry();
@@ -110,7 +112,6 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         uint256 lpToReserve;
 
         (lpToReserve, netLpOut, netScyUsed, netPtUsed) = market.addLiquidity(
-            index,
             netScyDesired,
             netPtDesired,
             block.timestamp
@@ -126,11 +127,10 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        require(
-            IERC20(SCY).balanceOf(address(this)) >= market.totalScy.Uint(),
-            "insufficient SCY"
-        );
-        require(IERC20(PT).balanceOf(address(this)) >= market.totalPt.Uint(), "insufficient PT");
+        if (_selfBalance(SCY) < market.totalScy.Uint())
+            revert Errors.MarketInsufficientScyReceived(_selfBalance(SCY), market.totalScy.Uint());
+        if (_selfBalance(PT) < market.totalPt.Uint())
+            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
 
         emit Mint(receiver, netLpOut, netScyUsed, netPtUsed);
     }
@@ -190,8 +190,8 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
             IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netScyOut.Int(), data);
         }
 
-        // have received enough PT
-        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)), "insufficient PT");
+        if (_selfBalance(PT) < market.totalPt.Uint())
+            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
 
         emit Swap(receiver, exactPtIn.neg(), netScyOut.Int(), netScyToReserve);
     }
@@ -228,10 +228,8 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         }
 
         // have received enough SCY
-        require(
-            market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)),
-            "insufficient SCY"
-        );
+        if (_selfBalance(SCY) < market.totalScy.Uint())
+            revert Errors.MarketInsufficientScyReceived(_selfBalance(SCY), market.totalScy.Uint());
 
         emit Swap(receiver, exactPtOut.Int(), netScyIn.neg(), netScyToReserve);
     }
@@ -239,8 +237,8 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     /// @notice force balances to match reserves
     function skim() external nonReentrant {
         MarketState memory market = readState();
-        uint256 excessPt = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
-        uint256 excessScy = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
+        uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
+        uint256 excessScy = _selfBalance(SCY) - market.totalScy.Uint();
         IERC20(PT).safeTransfer(market.treasury, excessPt);
         IERC20(SCY).safeTransfer(market.treasury, excessScy);
     }
@@ -306,12 +304,10 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     /// @notice write back the state of the market from memory to storage
     function _writeState(MarketState memory market) internal {
         uint96 lastLnImpliedRate96 = market.lastLnImpliedRate.Uint96();
+        int128 totalPt128 = market.totalPt.Int128();
+        int128 totalScy128 = market.totalScy.Int128();
 
-        _storage.totalPt = market.totalPt.Int128();
-        _storage.totalScy = market.totalScy.Int128();
-        _storage.lastLnImpliedRate = lastLnImpliedRate96;
-
-        (_storage.observationIndex, _storage.observationCardinality) = observations.write(
+        (uint16 observationIndex, uint16 observationCardinality) = observations.write(
             _storage.observationIndex,
             uint32(block.timestamp),
             lastLnImpliedRate96,
@@ -319,6 +315,12 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
             _storage.observationCardinalityNext
         );
 
+        _storage.totalPt = totalPt128;
+        _storage.totalScy = totalScy128;
+        _storage.lastLnImpliedRate = lastLnImpliedRate96;
+        _storage.observationIndex = observationIndex;
+        _storage.observationCardinality = observationCardinality;
+
         emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
     }
 

package/contracts/core/Market/PendleMarketFactory.sol

@@ -6,7 +6,8 @@ import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
 import "../../interfaces/IPMarketFactory.sol";
 
-import "../../libraries/helpers/SSTORE2Deployer.sol";
+import "../../libraries/helpers/BaseSplitCodeFactory.sol";
+import "../../libraries/Errors.sol";
 import "../../periphery/BoringOwnableUpgradeable.sol";
 
 import "./PendleMarket.sol";
@@ -22,8 +23,12 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         // 1 SLOT = 256 bits
     }
 
+    address public immutable marketCreationCodeContractA;
+    uint256 public immutable marketCreationCodeSizeA;
+    address public immutable marketCreationCodeContractB;
+    uint256 public immutable marketCreationCodeSizeB;
+
     address public immutable yieldContractFactory;
-    address public immutable marketCreationCodePointer;
     uint256 public immutable maxLnFeeRateRoot;
 
     // PT -> scalarRoot -> initialAnchor
@@ -34,12 +39,20 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
 
     MarketConfig public marketConfig;
 
-    constructor(address _yieldContractFactory, address _marketCreationCodePointer) {
-        require(_yieldContractFactory != address(0), "zero address");
+    constructor(
+        address _yieldContractFactory,
+        address _marketCreationCodeContractA,
+        uint256 _marketCreationCodeSizeA,
+        address _marketCreationCodeContractB,
+        uint256 _marketCreationCodeSizeB
+    ) {
         yieldContractFactory = _yieldContractFactory;
         maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * Math.IONE) / 100))); // ln(1.05)
 
-        marketCreationCodePointer = _marketCreationCodePointer;
+        marketCreationCodeContractA = _marketCreationCodeContractA;
+        marketCreationCodeSizeA = _marketCreationCodeSizeA;
+        marketCreationCodeContractB = _marketCreationCodeContractB;
+        marketCreationCodeSizeB = _marketCreationCodeSizeB;
     }
 
     function initialize(
@@ -49,8 +62,6 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         address newVePendle,
         address newGaugeController
     ) external initializer {
-        require(newVePendle != address(0) && newGaugeController != address(0), "zero address");
-
         __BoringOwnable_init();
         setTreasury(_treasury);
         setlnFeeRateRoot(_lnFeeRateRoot);
@@ -69,19 +80,26 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         int256 scalarRoot,
         int256 initialAnchor
     ) external returns (address market) {
-        require(!IPPrincipalToken(PT).isExpired(), "PT is expired");
-        require(IPYieldContractFactory(yieldContractFactory).isPT(PT), "Invalid PT");
-        require(markets[PT][scalarRoot][initialAnchor] == address(0), "market already created");
+        if (!IPYieldContractFactory(yieldContractFactory).isPT(PT))
+            revert Errors.MarketFactoryInvalidPt();
+        if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
+
+        if (markets[PT][scalarRoot][initialAnchor] != address(0))
+            revert Errors.MarketFactoryMarketExists();
 
-        // no need salt since market's existence has been checked before hand
-        market = SSTORE2Deployer.create2(
-            marketCreationCodePointer,
+        market = BaseSplitCodeFactory._create2(
+            0,
             bytes32(block.chainid),
-            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController)
+            abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController),
+            marketCreationCodeContractA,
+            marketCreationCodeSizeA,
+            marketCreationCodeContractB,
+            marketCreationCodeSizeB
         );
 
         markets[PT][scalarRoot][initialAnchor] = market;
-        require(allMarkets.add(market), "IE market can't be added");
+
+        if (!allMarkets.add(market)) assert(false);
 
         emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
     }
@@ -96,19 +114,22 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
-        require(newTreasury != address(0), "zero address");
         marketConfig.treasury = newTreasury;
         _emitNewMarketConfigEvent();
     }
 
-    function setlnFeeRateRoot(uint88 newlnFeeRateRoot) public onlyOwner {
-        require(newlnFeeRateRoot <= maxLnFeeRateRoot, "invalid fee rate root");
-        marketConfig.lnFeeRateRoot = newlnFeeRateRoot;
+    function setlnFeeRateRoot(uint88 newLnFeeRateRoot) public onlyOwner {
+        if (newLnFeeRateRoot > maxLnFeeRateRoot)
+            revert Errors.MFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
+
+        marketConfig.lnFeeRateRoot = newLnFeeRateRoot;
         _emitNewMarketConfigEvent();
     }
 
     function setReserveFeePercent(uint8 newReserveFeePercent) public onlyOwner {
-        require(newReserveFeePercent <= 100, "invalid reserve fee percent");
+        if (newReserveFeePercent > 100)
+            revert Errors.MFactoryReserveFeePercentTooHigh(newReserveFeePercent, 100);
+
         marketConfig.reserveFeePercent = newReserveFeePercent;
         _emitNewMarketConfigEvent();
     }

package/contracts/core/PendleERC20Permit.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol)
+
+pragma solidity ^0.8.0;
+
+import "./PendleERC20.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/utils/cryptography/draft-EIP712.sol";
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "@openzeppelin/contracts/utils/Counters.sol";
+
+/// @dev forked from OZ's ERC20Permit
+contract PendleERC20Permit is PendleERC20, IERC20Permit, EIP712 {
+    using Counters for Counters.Counter;
+
+    mapping(address => Counters.Counter) private _nonces;
+
+    // solhint-disable-next-line var-name-mixedcase
+    bytes32 private immutable _PERMIT_TYPEHASH =
+        keccak256(
+            "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
+        );
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint8 decimals_
+    ) PendleERC20(name_, symbol_, decimals_) EIP712(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();
+    }
+}

package/contracts/core/PendleRouter.sol

@@ -6,6 +6,7 @@ import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../interfaces/IPAllAction.sol";
 import "../interfaces/IPMarketSwapCallback.sol";
 import "../periphery/BoringOwnableUpgradeable.sol";
+import "../libraries/Errors.sol";
 
 /// @dev this contract will be deployed behind an ERC1967 proxy
 /// calls to the ERC1967 proxy will be resolved at this contract, and proxied again to the
@@ -96,7 +97,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
         } else if (sig == IPActionMisc.consult.selector) {
             return ACTION_MISC;
         }
-        require(false, "invalid market sig");
+        revert Errors.RouterInvalidAction(sig);
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,23 +4,24 @@ 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 "../../libraries/Errors.sol";
 import "@openzeppelin/contracts/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;
     address public YT;
 
     modifier onlyYT() {
-        require(msg.sender == address(YT), "ONLY_YT");
+        if (msg.sender != YT) revert Errors.OnlyYT();
         _;
     }
 
-    modifier onlyFactory() {
-        require(msg.sender == factory, "ONLY_FACTORY");
+    modifier onlYieldFactory() {
+        if (msg.sender != factory) revert Errors.OnlyYCFactory();
         _;
     }
 
@@ -30,13 +31,13 @@ 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;
     }
 
-    function initialize(address _YT) external initializer onlyFactory {
+    function initialize(address _YT) external initializer onlYieldFactory {
         YT = _YT;
     }
 

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -29,8 +29,9 @@ import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
 import "../../libraries/helpers/ExpiryUtilsLib.sol";
-import "../../libraries/helpers/SSTORE2Deployer.sol";
+import "../../libraries/helpers/BaseSplitCodeFactory.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
+import "../../libraries/Errors.sol";
 
 import "../../periphery/BoringOwnableUpgradeable.sol";
 
@@ -44,7 +45,10 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     string private constant PT_PREFIX = "PT";
     string private constant YT_PREFIX = "YT";
 
-    address public immutable pendleYtCreationCodePointer;
+    address public immutable ytCreationCodeContractA;
+    uint256 public immutable ytCreationCodeSizeA;
+    address public immutable ytCreationCodeContractB;
+    uint256 public immutable ytCreationCodeSizeB;
 
     // 1 SLOT
     uint128 public interestFeeRate; // a fixed point number
@@ -60,8 +64,16 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
-    constructor(address _pendleYtCreationCodePointer) {
-        pendleYtCreationCodePointer = _pendleYtCreationCodePointer;
+    constructor(
+        address _ytCreationCodeContractA,
+        uint256 _ytCreationCodeSizeA,
+        address _ytCreationCodeContractB,
+        uint256 _ytCreationCodeSizeB
+    ) {
+        ytCreationCodeContractA = _ytCreationCodeContractA;
+        ytCreationCodeSizeA = _ytCreationCodeSizeA;
+        ytCreationCodeContractB = _ytCreationCodeContractB;
+        ytCreationCodeSizeB = _ytCreationCodeSizeB;
     }
 
     function initialize(
@@ -85,31 +97,32 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
         external
         returns (address PT, address YT)
     {
-        require(!MiniHelpers.isTimeInThePast(expiry), "expiry must be in the future");
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
+            revert Errors.YCFactoryInvalidExpiry();
 
-        require(expiry % expiryDivisor == 0, "must be multiple of divisor");
-
-        require(getPT[SCY][expiry] == address(0), "PT already existed");
+        if (getPT[SCY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
 
         ISuperComposableYield _SCY = ISuperComposableYield(SCY);
 
         (, , uint8 assetDecimals) = _SCY.assetInfo();
 
-        // no need salt since PT (and also YT) existence has been checked before hand
-        PT = SSTORE2Deployer.create2(
-            type(PendlePrincipalToken).creationCode,
+        PT = Create2.deploy(
+            0,
             bytes32(block.chainid),
-            abi.encode(
-                SCY,
-                PT_PREFIX.concat(_SCY.name(), expiry, " "),
-                PT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
-                assetDecimals,
-                expiry
+            abi.encodePacked(
+                type(PendlePrincipalToken).creationCode,
+                abi.encode(
+                    SCY,
+                    PT_PREFIX.concat(_SCY.name(), expiry, " "),
+                    PT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
+                    assetDecimals,
+                    expiry
+                )
             )
         );
 
-        YT = SSTORE2Deployer.create2(
-            pendleYtCreationCodePointer,
+        YT = BaseSplitCodeFactory._create2(
+            0,
             bytes32(block.chainid),
             abi.encode(
                 SCY,
@@ -118,7 +131,11 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
                 YT_PREFIX.concat(_SCY.symbol(), expiry, "-"),
                 assetDecimals,
                 expiry
-            )
+            ),
+            ytCreationCodeContractA,
+            ytCreationCodeSizeA,
+            ytCreationCodeContractB,
+            ytCreationCodeSizeB
         );
 
         IPPrincipalToken(PT).initialize(YT);
@@ -132,7 +149,6 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     }
 
     function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
-        require(newExpiryDivisor != 0, "zero value");
         expiryDivisor = newExpiryDivisor;
         emit SetExpiryDivisor(newExpiryDivisor);
     }
@@ -148,7 +164,6 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     }
 
     function setTreasury(address newTreasury) public onlyOwner {
-        require(newTreasury != address(0), "zero address");
         treasury = newTreasury;
         emit SetTreasury(newTreasury);
     }