@pendle/core-v2 5.0.1 → 5.0.3

package/contracts/core/Market/v2/PendleMarketV2.sol

@@ -1,356 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "../../../interfaces/IPMarket.sol";
-import "../../../interfaces/IPMarketFactory.sol";
-import "../../../interfaces/IPMarketSwapCallback.sol";
-
-import "../../erc20/PendleERC20.sol";
-import "./PendleGaugeV2.sol";
-import "../OracleLib.sol";
-
-/**
-Invariance to maintain:
-- Internal balances totalPt & totalSy not interfered by people transferring tokens in directly
-- address(0) & address(this) should never have any rewards & activeBalance accounting done. This is
-    guaranteed by address(0) & address(this) check in each updateForTwo function
-*/
-contract PendleMarketV2 is PendleERC20, PendleGaugeV2, IPMarket {
-    using PMath for uint256;
-    using PMath for int256;
-    using MarketMathCore for MarketState;
-    using SafeERC20 for IERC20;
-    using PYIndexLib for IPYieldToken;
-    using OracleLib for OracleLib.Observation[65535];
-
-    struct MarketStorage {
-        int128 totalPt;
-        int128 totalSy;
-        // 1 SLOT = 256 bits
-        uint96 lastLnImpliedRate;
-        uint16 observationIndex;
-        uint16 observationCardinality;
-        uint16 observationCardinalityNext;
-        // 1 SLOT = 144 bits
-    }
-
-    string private constant NAME = "Pendle Market";
-    string private constant SYMBOL = "PENDLE-LPT";
-
-    IPPrincipalToken internal immutable PT;
-    IStandardizedYield internal immutable SY;
-    IPYieldToken internal immutable YT;
-
-    address public immutable factory;
-    uint256 public immutable expiry;
-    int256 public immutable scalarRoot;
-    int256 public immutable initialAnchor;
-
-    MarketStorage public _storage;
-
-    OracleLib.Observation[65535] public observations;
-
-    modifier notExpired() {
-        if (isExpired()) revert Errors.MarketExpired();
-        _;
-    }
-
-    constructor(
-        address _PT,
-        int256 _scalarRoot,
-        int256 _initialAnchor,
-        address _vePendle,
-        address _gaugeController,
-        address _externalRewardDistributor
-    )
-        PendleERC20(NAME, SYMBOL, 18)
-        PendleGaugeV2(IPPrincipalToken(_PT).SY(), _vePendle, _gaugeController, _externalRewardDistributor)
-    {
-        PT = IPPrincipalToken(_PT);
-        SY = IStandardizedYield(PT.SY());
-        YT = IPYieldToken(PT.YT());
-
-        (_storage.observationCardinality, _storage.observationCardinalityNext) = observations.initialize(
-            uint32(block.timestamp)
-        );
-
-        if (_scalarRoot <= 0) revert Errors.MarketScalarRootBelowZero(_scalarRoot);
-
-        scalarRoot = _scalarRoot;
-        initialAnchor = _initialAnchor;
-        expiry = IPPrincipalToken(_PT).expiry();
-        factory = msg.sender;
-    }
-
-    /**
-     * @notice PendleMarket allows users to provide in PT & SY in exchange for LPs, which
-     * will grant LP holders more exchange fee over time
-     * @dev will mint as much LP as possible such that the corresponding SY and PT used do
-     * not exceed `netSyDesired` and `netPtDesired`, respectively
-     * @dev PT and SY should be transferred to this contract prior to calling
-     * @dev will revert if PT is expired
-     */
-    function mint(
-        address receiver,
-        uint256 netSyDesired,
-        uint256 netPtDesired
-    ) external nonReentrant notExpired returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed) {
-        MarketState memory market = readState(msg.sender);
-        PYIndex index = YT.newIndex();
-
-        uint256 lpToReserve;
-
-        (lpToReserve, netLpOut, netSyUsed, netPtUsed) = market.addLiquidity(
-            netSyDesired,
-            netPtDesired,
-            block.timestamp
-        );
-
-        // initializing the market
-        if (lpToReserve != 0) {
-            market.setInitialLnImpliedRate(index, initialAnchor, block.timestamp);
-            _mint(address(1), lpToReserve);
-        }
-
-        _mint(receiver, netLpOut);
-
-        _writeState(market);
-
-        if (_selfBalance(SY) < market.totalSy.Uint())
-            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
-        if (_selfBalance(PT) < market.totalPt.Uint())
-            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
-
-        emit Mint(receiver, netLpOut, netSyUsed, netPtUsed);
-    }
-
-    /**
-     * @notice LP Holders can burn their LP to receive back SY & PT proportionally
-     * to their share of the market
-     */
-    function burn(
-        address receiverSy,
-        address receiverPt,
-        uint256 netLpToBurn
-    ) external nonReentrant returns (uint256 netSyOut, uint256 netPtOut) {
-        MarketState memory market = readState(msg.sender);
-
-        _burn(address(this), netLpToBurn);
-
-        (netSyOut, netPtOut) = market.removeLiquidity(netLpToBurn);
-
-        if (receiverSy != address(this)) IERC20(SY).safeTransfer(receiverSy, netSyOut);
-        if (receiverPt != address(this)) IERC20(PT).safeTransfer(receiverPt, netPtOut);
-
-        _writeState(market);
-
-        emit Burn(receiverSy, receiverPt, netLpToBurn, netSyOut, netPtOut);
-    }
-
-    /**
-     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
-     * aims to swap an exact amount of PT to SY.
-     * @dev steps working of this contract
-       - The outcome amount of SY will be precomputed by MarketMathLib
-       - Release the calculated amount of SY to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure exactPtIn amount of PT has been transferred to this address
-     * @dev will revert if PT is expired
-     * @param data bytes data to be sent in the callback (if any)
-     */
-    function swapExactPtForSy(
-        address receiver,
-        uint256 exactPtIn,
-        bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netSyOut, uint256 netSyFee) {
-        MarketState memory market = readState(msg.sender);
-
-        uint256 netSyToReserve;
-        (netSyOut, netSyFee, netSyToReserve) = market.swapExactPtForSy(YT.newIndex(), exactPtIn, block.timestamp);
-
-        if (receiver != address(this)) IERC20(SY).safeTransfer(receiver, netSyOut);
-        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
-
-        _writeState(market);
-
-        if (data.length > 0) {
-            IPMarketSwapCallback(msg.sender).swapCallback(exactPtIn.neg(), netSyOut.Int(), data);
-        }
-
-        if (_selfBalance(PT) < market.totalPt.Uint())
-            revert Errors.MarketInsufficientPtReceived(_selfBalance(PT), market.totalPt.Uint());
-
-        emit Swap(msg.sender, receiver, exactPtIn.neg(), netSyOut.Int(), netSyFee, netSyToReserve);
-    }
-
-    /**
-     * @notice Pendle Market allows swaps between PT & SY it is holding. This function
-     * aims to swap SY for an exact amount of PT.
-     * @dev steps working of this function
-       - The exact outcome amount of PT will be transferred to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure the calculated required amount of SY is transferred to this address
-     * @dev will revert if PT is expired
-     * @param data bytes data to be sent in the callback (if any)
-     */
-    function swapSyForExactPt(
-        address receiver,
-        uint256 exactPtOut,
-        bytes calldata data
-    ) external nonReentrant notExpired returns (uint256 netSyIn, uint256 netSyFee) {
-        MarketState memory market = readState(msg.sender);
-
-        uint256 netSyToReserve;
-        (netSyIn, netSyFee, netSyToReserve) = market.swapSyForExactPt(YT.newIndex(), exactPtOut, block.timestamp);
-
-        if (receiver != address(this)) IERC20(PT).safeTransfer(receiver, exactPtOut);
-        IERC20(SY).safeTransfer(market.treasury, netSyToReserve);
-
-        _writeState(market);
-
-        if (data.length > 0) {
-            IPMarketSwapCallback(msg.sender).swapCallback(exactPtOut.Int(), netSyIn.neg(), data);
-        }
-
-        // have received enough SY
-        if (_selfBalance(SY) < market.totalSy.Uint())
-            revert Errors.MarketInsufficientSyReceived(_selfBalance(SY), market.totalSy.Uint());
-
-        emit Swap(msg.sender, receiver, exactPtOut.Int(), netSyIn.neg(), netSyFee, netSyToReserve);
-    }
-
-    /// @notice forces balances to match reserves
-    function skim() external nonReentrant {
-        MarketState memory market = readState(msg.sender);
-        uint256 excessPt = _selfBalance(PT) - market.totalPt.Uint();
-        uint256 excessSy = _selfBalance(SY) - market.totalSy.Uint();
-        if (excessPt != 0) IERC20(PT).safeTransfer(market.treasury, excessPt);
-        if (excessSy != 0) IERC20(SY).safeTransfer(market.treasury, excessSy);
-    }
-
-    /**
-     * @notice redeems the user's reward
-     * @return amount of reward token redeemed, in the same order as `getRewardTokens()`
-     */
-    function redeemRewards(address user) external nonReentrant returns (uint256[] memory) {
-        return _redeemRewards(user);
-    }
-
-    /// @notice returns the list of reward tokens
-    function getRewardTokens() external view returns (address[] memory) {
-        return _getRewardTokens();
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                                ORACLE
-    //////////////////////////////////////////////////////////////*/
-
-    function observe(uint32[] memory secondsAgos) external view returns (uint216[] memory lnImpliedRateCumulative) {
-        return
-            observations.observe(
-                uint32(block.timestamp),
-                secondsAgos,
-                _storage.lastLnImpliedRate,
-                _storage.observationIndex,
-                _storage.observationCardinality
-            );
-    }
-
-    function increaseObservationsCardinalityNext(uint16 cardinalityNext) external nonReentrant {
-        uint16 cardinalityNextOld = _storage.observationCardinalityNext;
-        uint16 cardinalityNextNew = observations.grow(cardinalityNextOld, cardinalityNext);
-        if (cardinalityNextOld != cardinalityNextNew) {
-            _storage.observationCardinalityNext = cardinalityNextNew;
-            emit IncreaseObservationCardinalityNext(cardinalityNextOld, cardinalityNextNew);
-        }
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                                READ/WRITE STATES
-    //////////////////////////////////////////////////////////////*/
-
-    /**
-     * @notice read the state of the market from storage into memory for gas-efficient manipulation
-     */
-    function readState(address router) public view returns (MarketState memory market) {
-        market.totalPt = _storage.totalPt;
-        market.totalSy = _storage.totalSy;
-        market.totalLp = totalSupply().Int();
-
-        (market.treasury, market.lnFeeRateRoot, market.reserveFeePercent) = IPMarketFactory(factory).getMarketConfig(
-            router
-        );
-
-        market.scalarRoot = scalarRoot;
-        market.expiry = expiry;
-
-        market.lastLnImpliedRate = _storage.lastLnImpliedRate;
-    }
-
-    /// @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 totalSy128 = market.totalSy.Int128();
-
-        (uint16 observationIndex, uint16 observationCardinality) = observations.write(
-            _storage.observationIndex,
-            uint32(block.timestamp),
-            _storage.lastLnImpliedRate,
-            _storage.observationCardinality,
-            _storage.observationCardinalityNext
-        );
-
-        _storage.totalPt = totalPt128;
-        _storage.totalSy = totalSy128;
-        _storage.lastLnImpliedRate = lastLnImpliedRate96;
-        _storage.observationIndex = observationIndex;
-        _storage.observationCardinality = observationCardinality;
-
-        emit UpdateImpliedRate(block.timestamp, market.lastLnImpliedRate);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                            TRIVIAL FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
-    function readTokens() external view returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT) {
-        _SY = SY;
-        _PT = PT;
-        _YT = YT;
-    }
-
-    function isExpired() public view returns (bool) {
-        return MiniHelpers.isCurrentlyExpired(expiry);
-    }
-
-    /*///////////////////////////////////////////////////////////////
-                    PENDLE GAUGE - RELATED
-    //////////////////////////////////////////////////////////////*/
-
-    function _stakedBalance(address user) internal view override returns (uint256) {
-        return balanceOf(user);
-    }
-
-    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, PendleGaugeV2) {
-        PendleGaugeV2._beforeTokenTransfer(from, to, amount);
-    }
-
-    // solhint-disable-next-line ordering
-    function _afterTokenTransfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal override(PendleERC20, PendleGaugeV2) {
-        PendleGaugeV2._afterTokenTransfer(from, to, amount);
-    }
-}

package/contracts/core/RewardManager/PendleLinearDistributor.sol

@@ -1,143 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity ^0.8.17;
-
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
-import "../libraries/BoringOwnableUpgradeable.sol";
-import "../libraries/TokenHelper.sol";
-import "../libraries/math/PMath.sol";
-import "../../interfaces/IPLinearDistributor.sol";
-
-contract PendleLinearDistributor is UUPSUpgradeable, AccessControlUpgradeable, TokenHelper, IPLinearDistributor {
-    using PMath for uint128;
-    using PMath for uint192;
-    using PMath for uint256;
-
-    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
-
-    mapping(address => bool) internal isWhitelisted;
-
-    // [token, addr] => distribution
-    mapping(address => mapping(address => DistributionData)) public distributionDatas;
-
-    constructor() {
-        _disableInitializers();
-    }
-
-    modifier onlyWhitelisted() {
-        require(isWhitelisted[msg.sender], "not whitelisted");
-        _;
-    }
-
-    function isMaintainer(address addr) public view returns (bool) {
-        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
-    }
-
-    modifier onlyMaintainer() {
-        require(isMaintainer(msg.sender), "not maintainer");
-        _;
-    }
-
-    modifier onlyAdmin() {
-        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not admin");
-        _;
-    }
-
-    // ----------------- core-logic ----------------------
-
-    function queueVestAndClaim(address token, uint256 amountVestToQueue) external onlyWhitelisted returns (uint256) {
-        require(amountVestToQueue > 0, "invalid amountVestToQueue");
-
-        uint256 amountOut = _getClaimableRewardAndUpdate(token, msg.sender, amountVestToQueue);
-
-        // dodging extreme case of amountOut = amountVestToQueue
-        if (amountOut > amountVestToQueue) {
-            _transferOut(token, msg.sender, amountOut - amountVestToQueue);
-        } else if (amountVestToQueue > amountOut) {
-            _transferIn(token, msg.sender, amountVestToQueue - amountOut);
-        }
-
-        emit VestQueued(token, msg.sender, amountVestToQueue);
-        emit Claim(token, msg.sender, amountOut);
-
-        return amountOut;
-    }
-
-    function claim(address token) external returns (uint256) {
-        uint256 amountOut = _getClaimableRewardAndUpdate(token, msg.sender, 0);
-        if (amountOut > 0) {
-            _transferOut(token, msg.sender, amountOut);
-        }
-        emit Claim(token, msg.sender, amountOut);
-        return amountOut;
-    }
-
-    function applyVestRewards(
-        address[] memory tokens,
-        address[] memory addrs,
-        uint256[] memory durations
-    ) external onlyMaintainer {
-        require(tokens.length == addrs.length, "invalid array length");
-        require(tokens.length == durations.length, "invalid array length");
-
-        for (uint256 i = 0; i < tokens.length; ++i) {
-            _applyVestReward(tokens[i], addrs[i], durations[i]);
-        }
-    }
-
-    function _applyVestReward(address token, address addr, uint256 duration) internal {
-        DistributionData memory data = _updateRewardView(token, addr);
-
-        uint256 amountVesting = data.unvestedReward;
-        if (amountVesting == 0) {
-            return;
-        }
-
-        uint256 leftOver = data.rewardPerSec.mulDown((data.endTime - PMath.min(block.timestamp, data.endTime)));
-        uint256 undistrbutedReward = amountVesting + leftOver;
-
-        data.unvestedReward = 0;
-        data.endTime = (block.timestamp + duration).Uint32();
-        data.rewardPerSec = undistrbutedReward.divDown(duration).Uint192();
-        distributionDatas[token][addr] = data;
-
-        emit Vested(token, addr, amountVesting, duration);
-    }
-
-    // data.lastDistributedTime is guaranteed to be block.timestamp after calling this
-    function _getClaimableRewardAndUpdate(
-        address token,
-        address addr,
-        uint256 amountVestToQueue
-    ) internal returns (uint256 amountOut) {
-        DistributionData memory data = _updateRewardView(token, addr);
-        amountOut = data.accruedReward;
-
-        data.accruedReward = 0;
-        data.unvestedReward += amountVestToQueue.Uint128();
-
-        distributionDatas[token][addr] = data;
-    }
-
-    function _updateRewardView(address token, address addr) internal view returns (DistributionData memory data) {
-        data = distributionDatas[token][addr];
-        uint256 distributeFrom = PMath.min(data.lastDistributedTime, data.endTime);
-        uint256 distributeTo = PMath.min(block.timestamp, data.endTime);
-        data.accruedReward += data.rewardPerSec.mulDown(distributeTo - distributeFrom).Uint128();
-        data.lastDistributedTime = block.timestamp.Uint32();
-    }
-
-    // ----------------- governance-related --------------
-
-    function setWhitelisted(address addr, bool status) external onlyAdmin {
-        isWhitelisted[addr] = status;
-    }
-
-    function initialize() external initializer {
-        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
-    }
-
-    // ----------------- upgrade-related -----------------
-
-    function _authorizeUpgrade(address) internal override onlyAdmin {}
-}

package/contracts/core/YieldContractsV2/InterestManagerYTV2.sol

@@ -1,105 +0,0 @@
-// 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/PMath.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 PMath 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

@@ -1,63 +0,0 @@
-// 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/PendleERC20.sol";
-
-import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
-
-contract PendlePrincipalTokenV2 is PendleERC20, 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
-    ) PendleERC20(_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);
-    }
-}