@pendle/core-v2 1.4.0-mainnet → 2.0.0-mainnet

package/contracts/core/StandardizedYield/implementations/GLP/GLPPreviewHelper.sol

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+import "../../../../interfaces/GMX/IVaultPriceFeed.sol";
+
+abstract contract GLPPreviewHelper {
+    // Based on Vault functions
+
+    IGMXVault public immutable vault;
+    address internal immutable usdg;
+    uint256 public constant PRICE_PRECISION = 10**30;
+    uint256 public constant BASIS_POINTS_DIVISOR = 10000;
+
+    constructor(address _vaultAddress) {
+        vault = IGMXVault(_vaultAddress);
+        usdg = vault.usdg();
+    }
+
+    function _buyUSDG(address _token, uint256 tokenAmount) internal view returns (uint256) {
+        tokenAmount = __transferIn(_token, tokenAmount);
+        assert(tokenAmount > 0);
+
+        uint256 price = vault.getMinPrice(_token);
+
+        uint256 usdgAmount = (tokenAmount * price) / PRICE_PRECISION;
+        usdgAmount = vault.adjustForDecimals(usdgAmount, _token, usdg);
+        require(usdgAmount > 0, "preview buyUSDG: usdgAmount must be > 0");
+
+        uint256 feeBasisPoints = __getFeeBasisPoints(
+            _token,
+            usdgAmount,
+            0,
+            vault.mintBurnFeeBasisPoints(),
+            vault.taxBasisPoints(),
+            true
+        );
+        uint256 amountAfterFees = __collectSwapFees(_token, tokenAmount, feeBasisPoints);
+        uint256 mintAmount = (amountAfterFees * price) / PRICE_PRECISION;
+        mintAmount = vault.adjustForDecimals(mintAmount, _token, usdg);
+
+        return mintAmount;
+    }
+
+    function _sellUSDG(address _token, uint256 usdgAmount) internal view returns (uint256) {
+        usdgAmount = __transferIn(usdg, usdgAmount);
+        assert(usdgAmount > 0);
+
+        uint256 redemptionAmount = vault.getRedemptionAmount(_token, usdgAmount);
+        require(redemptionAmount > 0, "preview sellUSDG: redemptionAmount must be > 0");
+
+        uint256 feeBasisPoints = __getFeeBasisPoints(
+            _token,
+            usdgAmount,
+            usdgAmount,
+            vault.mintBurnFeeBasisPoints(),
+            vault.taxBasisPoints(),
+            false
+        );
+        uint256 amountOut = __collectSwapFees(_token, redemptionAmount, feeBasisPoints);
+        require(amountOut > 0, "preview sellUSDG: amountOut must be > 0");
+
+        return amountOut;
+    }
+
+    function __transferIn(address _token, uint256 _amount) private view returns (uint256) {
+        uint256 prevBalance = vault.tokenBalances(_token);
+        uint256 nextBalance = IERC20(_token).balanceOf(address(vault)) + _amount;
+
+        return nextBalance - prevBalance;
+    }
+
+    function __collectSwapFees(
+        address, /*_token*/
+        uint256 _amount,
+        uint256 _feeBasisPoints
+    ) private pure returns (uint256) {
+        uint256 afterFeeAmount = (_amount * (BASIS_POINTS_DIVISOR - _feeBasisPoints)) /
+            (BASIS_POINTS_DIVISOR);
+        return afterFeeAmount;
+    }
+
+    function __getFeeBasisPoints(
+        address _token,
+        uint256 _usdgDelta,
+        uint256 _burnedUsdg,
+        uint256 _feeBasisPoints,
+        uint256 _taxBasisPoints,
+        bool _increment
+    ) private view returns (uint256) {
+        if (!vault.hasDynamicFees()) {
+            return _feeBasisPoints;
+        }
+
+        uint256 initialAmount = vault.usdgAmounts(_token);
+        initialAmount = (initialAmount >= _burnedUsdg) ? initialAmount - _burnedUsdg : 0;
+
+        uint256 nextAmount = initialAmount + _usdgDelta;
+        if (!_increment) {
+            nextAmount = _usdgDelta > initialAmount ? 0 : initialAmount - _usdgDelta;
+        }
+
+        uint256 targetAmount = __getTargetUsdgAmount(_token, _burnedUsdg);
+        if (targetAmount == 0) {
+            return _feeBasisPoints;
+        }
+
+        uint256 initialDiff = initialAmount > targetAmount
+            ? initialAmount - targetAmount
+            : targetAmount - initialAmount;
+        uint256 nextDiff = nextAmount > targetAmount
+            ? nextAmount - targetAmount
+            : targetAmount - nextAmount;
+
+        // action improves relative asset balance
+        if (nextDiff < initialDiff) {
+            uint256 rebateBps = (_taxBasisPoints * initialDiff) / targetAmount;
+            return rebateBps > _feeBasisPoints ? 0 : _feeBasisPoints - rebateBps;
+        }
+
+        uint256 averageDiff = (initialDiff + nextDiff) / 2;
+        if (averageDiff > targetAmount) {
+            averageDiff = targetAmount;
+        }
+        uint256 taxBps = (_taxBasisPoints * averageDiff) / targetAmount;
+        return _feeBasisPoints + taxBps;
+    }
+
+    function __getTargetUsdgAmount(address _token, uint256 _burnedUsdg)
+        private
+        view
+        returns (uint256)
+    {
+        uint256 supply = IERC20(usdg).totalSupply() - _burnedUsdg;
+        if (supply == 0) {
+            return 0;
+        }
+        uint256 weight = vault.tokenWeights(_token);
+        return (weight * supply) / vault.totalTokenWeights();
+    }
+}

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

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "./GLPPreviewHelper.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../../interfaces/GMX/IRewardRouterV2.sol";
+import "../../../../interfaces/GMX/IGlpManager.sol";
+import "../../../../interfaces/GMX/IGMXVault.sol";
+
+contract PendleGlpSY is SYBaseWithRewards, GLPPreviewHelper {
+    using ArrayLib for address[];
+
+    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) GLPPreviewHelper(_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).handleRewards(false, false, true, true, false, true, false);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    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 _getGlpWhitelistedTokens() internal view returns (address[] memory res) {
+        res = new address[](0);
+        uint256 length = vault.allWhitelistedTokensLength();
+        for(uint256 i = 0; i < length; ++i) {
+            address token = vault.allWhitelistedTokens(i);
+            if (vault.whitelistedTokens(token) && !res.contains(token)) {
+                res = res.append(token);
+            }
+        }
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory res) {
+        return _getGlpWhitelistedTokens();
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory res) {
+        return _getGlpWhitelistedTokens();
+    }
+
+    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/GLP/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);
+    }
+}