@pendle/core-v2 1.0.0-mainnet → 1.0.0-testnet

package/contracts/core/StandardizedYield/implementations/GMX/PendleGlpSY.sol

@@ -0,0 +1,244 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./GMXPreviewHelper.sol";
+import "../../../../interfaces/GMX/IRewardRouterV2.sol";
+import "../../../../interfaces/GMX/IGlpManager.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+
+contract PendleGlpSY is SYBaseWithRewards, GMXPreviewHelper {
+    address public immutable glp;
+    address public immutable stakedGlp;
+    address public immutable rewardRouter;
+    address public immutable glpRouter;
+    address public immutable glpManager;
+    address public immutable weth;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _glp,
+        address _fsGlp,
+        address _stakedGlp,
+        address _rewardRouter,
+        address _glpRouter,
+        address _vault
+    ) SYBaseWithRewards(_name, _symbol, _fsGlp) GMXPreviewHelper(_vault) {
+        glp = _glp;
+        stakedGlp = _stakedGlp;
+        rewardRouter = _rewardRouter;
+        glpRouter = _glpRouter;
+        glpManager = IRewardRouterV2(glpRouter).glpManager();
+        weth = IRewardRouterV2(glpRouter).weth();
+
+        approveAllWhitelisted();
+    }
+
+    function approveAllWhitelisted() public {
+        uint256 length = vault.allWhitelistedTokensLength();
+        for (uint256 i = 0; i < length; ++i) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token)) {
+                _safeApproveInf(token, glpManager);
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {SYBase-_deposit}
+     */
+    function _deposit(address tokenIn, uint256 amountDeposited)
+        internal
+        virtual
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == stakedGlp) {
+            // GLP is already staked in stakedGlp's transferFrom, called in _transferIn()
+            amountSharesOut = amountDeposited;
+        } else if (tokenIn == NATIVE) {
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlpETH{ value: msg.value }(
+                0,
+                0
+            );
+        } else {
+            amountSharesOut = IRewardRouterV2(glpRouter).mintAndStakeGlp(
+                tokenIn,
+                amountDeposited,
+                0,
+                0
+            );
+        }
+    }
+
+    /**
+     * @dev See {SYBase-_redeem}
+     */
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == stakedGlp) {
+            amountTokenOut = amountSharesToRedeem;
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        } else if (tokenOut == NATIVE) {
+            amountTokenOut = IRewardRouterV2(glpRouter).unstakeAndRedeemGlpETH(
+                amountSharesToRedeem,
+                0,
+                payable(receiver)
+            );
+        } else {
+            amountTokenOut = IRewardRouterV2(glpRouter).unstakeAndRedeemGlp(
+                tokenOut,
+                amountSharesToRedeem,
+                0,
+                receiver
+            );
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Calculates and updates the exchange rate of shares to underlying asset token
+     * @dev 1 SY = 1 GLP
+     */
+    function exchangeRate() public view virtual override returns (uint256) {
+        return Math.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory res) {
+        res = new address[](1);
+        res[0] = weth;
+    }
+
+    function _redeemExternalReward() internal override {
+        IRewardRouterV2(rewardRouter).claim();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
+        internal
+        view
+        override
+        returns (uint256 amountSharesOut)
+    {
+        if (tokenIn == stakedGlp) amountSharesOut = amountTokenToDeposit;
+        else {
+            if (tokenIn == NATIVE) tokenIn = weth;
+
+            // Based on GlpManager's _addLiquidity
+            uint256 aumInUsdg = IGlpManager(glpManager).getAumInUsdg(true);
+            uint256 glpSupply = IERC20(glp).totalSupply();
+            uint256 usdgAmount = super._buyUSDG(tokenIn, amountTokenToDeposit);
+
+            uint256 mintAmount = aumInUsdg == 0
+                ? usdgAmount
+                : (usdgAmount * glpSupply) / aumInUsdg;
+            amountSharesOut = mintAmount;
+        }
+    }
+
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
+        internal
+        view
+        override
+        returns (uint256 amountTokenOut)
+    {
+        if (tokenOut == stakedGlp) amountTokenOut = amountSharesToRedeem;
+        else {
+            if (tokenOut == NATIVE) tokenOut = weth;
+
+            // Based on GlpManager's _removeLiquidity
+            uint256 aumInUsdg = IGlpManager(glpManager).getAumInUsdg(false);
+            uint256 glpSupply = IERC20(glp).totalSupply();
+
+            uint256 usdgAmount = (amountSharesToRedeem * aumInUsdg) / glpSupply;
+            uint256 amountOut = super._sellUSDG(tokenOut, usdgAmount);
+
+            amountTokenOut = amountOut;
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        res = new address[](vault.whitelistedTokenCount() + 2);
+        res[0] = stakedGlp;
+        res[1] = NATIVE;
+
+        uint256 resIndex = 2;
+        uint256 length = vault.allWhitelistedTokensLength();
+        for (uint256 i = 0; i < length; ) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token)) {
+                res[resIndex] = token;
+                unchecked {
+                    ++resIndex;
+                }
+            }
+            unchecked {
+                ++i;
+            }
+        }
+        require(resIndex == res.length, "Wrong whitelisted tokens count");
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        res = new address[](vault.whitelistedTokenCount() + 2);
+        res[0] = stakedGlp;
+        res[1] = NATIVE;
+
+        uint256 resIndex = 2;
+        uint256 length = vault.allWhitelistedTokensLength();
+        for (uint256 i = 0; i < length; ) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token)) {
+                res[resIndex] = token;
+                unchecked {
+                    ++resIndex;
+                }
+            }
+            unchecked {
+                ++i;
+            }
+        }
+        require(resIndex == res.length, "Wrong whitelisted tokens count");
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == stakedGlp || token == NATIVE || vault.whitelistedTokens(token);
+    }
+
+    function assetInfo()
+        external
+        view
+        returns (
+            AssetType assetType,
+            address assetAddress,
+            uint8 assetDecimals
+        )
+    {
+        return (AssetType.LIQUIDITY, glp, IERC20Metadata(glp).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/GMX/README.md

@@ -0,0 +1,61 @@
+# Audit note GLP SY
+
+Our goal is to support SY for the GLP token of GMX.
+
+The SY supports mint-and-staking GLP with a whitelisted token (ETH, WBTC, etc) or receiving staked GLP from user.
+
+## Overview
+
++ _The main contract_ for the SY is: `PendleGlpSY.sol`.  
+This contract contains the main logic ofk all SY operations, except GMX's Vault-related logic for preview functions. This part is contained in the abstract preview contract, which is inherited by the main contract.
+
+- _The preview contract_ is: `GMXPreviewHelper.sol`.  
+This contract simulates the logic of GMX's Vault to preview buying/selling USDG during deposit/redeem.
+
+## About PendleGlpSY
+
+A typical, ordinary SY contract.
+
+- _Constructor_: Initialize global variables and approve whitelisted tokens to GMX's GlpManager, which would pull tokens in from the SY contract when minting GLP.
+    - There are two routers: _rewardRouter_ is used for claiming rewards,, _glpRouter_ is used to deposit/redeem; hence the two global router variables.
+- _Deposit_:
+    - In case of receiving staked GLP, then staked GLP is already pulled in with _transferIn() in SYBase. 
+    **Note:** StakedGLP (sGLP) is a helper contract by GMX for users to transfer their staked GLP between each other, where staking and unstaking happen behind the scenes. It is not an ERC20 token, but it behaves similar enough to one so that we treat it is ERC20 in the contract.
+    - Otherwise, use GlpRewardRouter to mint and stake.
+- _Redeem_: Same as deposit, reversed. If user redeems in staked GLP, _transferOut() is used for staked GLP.
+- _Exchange rate_: The SY directly wraps GLP, so the exchange rate is always 1.
+- _Preview deposit_: Mimics the logic of _\_addLiquidity()_ in GMX's GlpManager. The functions needs to preview _buyUSDG()_ of GMX's Vault, which is mimicked in GMXPreviewHelper.
+- _Preview redeem_: Mimics the logic of _\_removeLiquidity()_ in GMX's GlpManager. The functions needs to preview _sellUSDG()_ of GMX's Vault, which is also mimicked in GMXPreviewHelper.
+- _Get tokens in/out_: Queries whitelisted tokens from GMX's Vault, then return them along with staked GLP and native ETH.
+- _Check valid token in/out_: Calls _whitelistedTokens()_ from GMX's Vault to check.
+
+## About GMXPreviewHelper
+
+This contract's purpose is to support preview for _buyUSDG()_ and _sellUSDG()_ functions from GMX's Vault. The contracts has two view functions _buyUSDG()_ and _sellUSDG()_ which mimics their respective Vault counterpart's logic.
+
+About _buyUSDG()_:
+- First, _tokenAmount_ is calculated with _transferIn(), which should give the same as the corresponding Vault function.
+- _updateCumulativeFundingRate()_ in Vault should not impact amount out, so this is ignored.
+- For _price_ and _usdgAmount_, the Vault view functions used in Vault's buyUSDG() should behave the same as during actual redeeming, so they are called directly from Vault.
+- For _feeBasisPoints_, _getFeeBasisPoints()_ also behave the same as Vault, becacuse the extra parameter _\_burnedUsdg_ = 0 which has no affect on the return value.
+- For _amountAfterFees_, see _\_collectSwapFees()_ below.
+- Finally, _mintAmount_ is calculated normally.
+
+About _sellUSDG()_:
+- Again, first _usdgAmount_ is calculated.
+- _updateCumulativeFundingRate()_ in Vault should not impact amount out, so this is ignored.
+- We directly call Vault's getRedemptionAmount() to calculate _redemptionAmount_. Although _useSwapPricing_ is set to true earlier in Vault's _sellUSDG()_, and _getRedemptionAmount()_ calls _getMaxPrice()_, which then calls priceFeed's _getPrice()_ with _useSwapPricing_ as a parameter, this parameter is then ignored in _getPrice()_. So we can ignore _useSwapPricing_, and Vault's _getRedemptionAmount()_ called in preview should behave the same as actual redeem.
+- Next, _decreaseUsdgAmount() and USDG's _burn()_ are called. This affects USDG balances, which would later affect _getFeeBasisPoints()_. 
+- _poolAmounts_ and _tokenBalances_ should not affect the amount out, so _\_decreasePoolAmount()_ and _\_updateTokenBalance()_ are ignored.
+- For _feeBasisPoints_, we need _getFeeBasisPoints()_. But _usdgAmounts[\_token]_ has been decreased by _usdgAmount_, so we account for this by adding parameter _\_burnedUsdg_ in our "fake" _getFeeBasisPoints()_.
+- Finally, _amountOut_ is calculated with _\_collectSwapFees()_.
+
+Other helper functions:
+- _\_transferIn()_: Mimics Vault's counterpart, should return the same value.
+- _\_collectSwapFees()_: In Vault, this function only changes _feeReserves_ which does not affect deposit/redeem, so we only need the _afterFeeAmount_.
+- _getFeeBasisPoints()_: Since USDG balances are affected in _sellUSDG()_, another parameter _\_burnedUsdg_ is introduced to account for this decrease in USDG. Namely, this affects:
+    - _initialAmount_: The new _usdgAmount[\_token]_ is different, which is calculated here similar to Vault's decreaseUsdgAmount().
+    - _getTargetUsdgAmount()_: The formula for the target amount concerns the total supply of USDG, which is affected by _burn()_ in _sellUSDG()_. This is accounted for in our "fake" _getTargetUsdgAmount()_, which takes _\_burnedUsdg_ as parameter and uses it to calculate the real _supply_.
+
+In our tests, all - intermediate and final return - values perfectly matches between Vault's functions and our replicas.
+

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);
+    }
+}

package/contracts/core/YieldContractsV2/PendleYieldContractFactoryV2.sol

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.17;
+
+import "../../interfaces/IPYieldContractFactory.sol";
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+
+import "../libraries/ExpiryUtilsLib.sol";
+import "../libraries/BaseSplitCodeFactory.sol";
+import "../libraries/MiniHelpers.sol";
+import "../libraries/Errors.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+import "../libraries/StringLib.sol";
+
+import "./PendlePrincipalTokenV2.sol";
+import "./PendleYieldTokenV2.sol"; 
+
+/// @dev If this contract is ever made upgradeable, please pay attention to the numContractDeployed variable
+contract PendleYieldContractFactoryV2 is BoringOwnableUpgradeable, IPYieldContractFactory {
+    using ExpiryUtils for string;
+    using StringLib for string;
+    using StringLib for StringLib.slice;
+
+    string private constant PT_PREFIX = "PT";
+    string private constant YT_PREFIX = "YT";
+    string private constant SY_SYMBOL_PREF = "SY-";
+    string private constant SY_NAME_PREF = "SY ";
+
+    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
+    uint128 public rewardFeeRate; // a fixed point number
+
+    // 1 SLOT
+    address public treasury;
+    uint96 public expiryDivisor;
+
+    // SY => expiry => address
+    // returns address(0) if not created
+    mapping(address => mapping(uint256 => address)) public getPT;
+    mapping(address => mapping(uint256 => address)) public getYT;
+    mapping(address => bool) public isPT;
+    mapping(address => bool) public isYT;
+
+    uint256 public constant maxInterestFeeRate = 2e17; // 20%
+    uint256 public constant maxRewardFeeRate = 2e17; // 20%
+
+    constructor(
+        address _ytCreationCodeContractA,
+        uint256 _ytCreationCodeSizeA,
+        address _ytCreationCodeContractB,
+        uint256 _ytCreationCodeSizeB
+    ) {
+        ytCreationCodeContractA = _ytCreationCodeContractA;
+        ytCreationCodeSizeA = _ytCreationCodeSizeA;
+        ytCreationCodeContractB = _ytCreationCodeContractB;
+        ytCreationCodeSizeB = _ytCreationCodeSizeB;
+    }
+
+    function initialize(
+        uint96 _expiryDivisor,
+        uint128 _interestFeeRate,
+        uint128 _rewardFeeRate,
+        address _treasury
+    ) external initializer {
+        __BoringOwnable_init();
+        setExpiryDivisor(_expiryDivisor);
+        setInterestFeeRate(_interestFeeRate);
+        setRewardFeeRate(_rewardFeeRate);
+        setTreasury(_treasury);
+    }
+
+    /**
+     * @notice Create a pair of (PT, YT) from any SY and valid expiry. Anyone can create a yield contract
+     * @dev It's intentional to make expiry an uint32 to guard against fat fingers. uint32.max is year 2106
+     */
+    function createYieldContract(
+        address SY,
+        uint32 expiry,
+        bool doCacheIndexSameBlock
+    ) external returns (address PT, address YT) {
+        if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
+            revert Errors.YCFactoryInvalidExpiry();
+
+        if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
+
+        IStandardizedYield _SY = IStandardizedYield(SY);
+
+        (, , uint8 assetDecimals) = _SY.assetInfo();
+
+        string memory syCoreName = _stripSYPrefix(_SY.name());
+        string memory syCoreSymbol = _stripSYPrefix(_SY.symbol());
+
+        PT = Create2.deploy(
+            0,
+            bytes32(block.chainid),
+            abi.encodePacked(
+                type(PendlePrincipalTokenV2).creationCode,
+                abi.encode(
+                    SY,
+                    PT_PREFIX.concat(syCoreName, expiry, " "),
+                    PT_PREFIX.concat(syCoreSymbol, expiry, "-"),
+                    assetDecimals,
+                    expiry
+                )
+            )
+        );
+
+        YT = BaseSplitCodeFactory._create2(
+            0,
+            bytes32(block.chainid),
+            abi.encode(
+                SY,
+                PT,
+                YT_PREFIX.concat(syCoreName, expiry, " "),
+                YT_PREFIX.concat(syCoreSymbol, expiry, "-"),
+                assetDecimals,
+                expiry,
+                doCacheIndexSameBlock
+            ),
+            ytCreationCodeContractA,
+            ytCreationCodeSizeA,
+            ytCreationCodeContractB,
+            ytCreationCodeSizeB
+        );
+
+        IPPrincipalToken(PT).initialize(YT);
+
+        getPT[SY][expiry] = PT;
+        getYT[SY][expiry] = YT;
+        isPT[PT] = true;
+        isYT[YT] = true;
+
+        emit CreateYieldContract(SY, expiry, PT, YT);
+    }
+
+    function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
+        if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
+
+        expiryDivisor = newExpiryDivisor;
+        emit SetExpiryDivisor(newExpiryDivisor);
+    }
+
+    function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
+        if (newInterestFeeRate > maxInterestFeeRate)
+            revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
+
+        interestFeeRate = newInterestFeeRate;
+        emit SetInterestFeeRate(newInterestFeeRate);
+    }
+
+    function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
+        if (newRewardFeeRate > maxRewardFeeRate)
+            revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
+
+        rewardFeeRate = newRewardFeeRate;
+        emit SetRewardFeeRate(newRewardFeeRate);
+    }
+
+    function setTreasury(address newTreasury) public onlyOwner {
+        if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
+
+        treasury = newTreasury;
+        emit SetTreasury(newTreasury);
+    }
+
+    function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
+        StringLib.slice memory str = _str.toSlice();
+        StringLib.slice memory delim_name = SY_NAME_PREF.toSlice();
+        StringLib.slice memory delim_symbol = SY_SYMBOL_PREF.toSlice();
+        return str.beyond(delim_name).beyond(delim_symbol).toString();
+    }
+}