@pendle/core-v2 0.7.0 → 0.7.1-beta

package/contracts/core/LiquidityMining/CelerAbstracts/{CelerReceiver.sol → CelerReceiverUpg.sol}

@@ -1,15 +1,21 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../../interfaces/ICelerMessageReceiverApp.sol";
 import "../../../periphery/PermissionsV2Upg.sol";
 
 // solhint-disable no-empty-blocks
-abstract contract CelerReceiver is ICelerMessageReceiverApp, PermissionsV2Upg {
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+abstract contract CelerReceiverUpg is ICelerMessageReceiverApp, PermissionsV2Upg {
     address public celerMessageBus;
     address public originAddress;
     uint256 public originChainId;
 
+    uint256[100] private __gap;
+
     constructor(address _governanceManager) PermissionsV2Upg(_governanceManager) {}
 
     modifier onlyCelerOrGov() {

package/contracts/core/LiquidityMining/CelerAbstracts/{CelerSender.sol → CelerSenderUpg.sol}

@@ -1,17 +1,24 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../../interfaces/ICelerMessageBus.sol";
 import "../../../periphery/PermissionsV2Upg.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
 // solhint-disable no-empty-blocks
-abstract contract CelerSender is PermissionsV2Upg {
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+abstract contract CelerSenderUpg is PermissionsV2Upg {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
-    ICelerMessageBus private celerMessageBus;
+    ICelerMessageBus public celerMessageBus;
+
     EnumerableMap.UintToAddressMap internal sidechainContracts;
 
+    uint256[100] private __gap;
+
     constructor(address _governanceManager) PermissionsV2Upg(_governanceManager) {}
 
     function setCelerMessageBus(address _celerMessageBus) external onlyGovernance {

package/contracts/core/LiquidityMining/GaugeController/{PendleGaugeController.sol → PendleGaugeControllerBaseUpg.sol}

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../../interfaces/IPGaugeController.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
@@ -17,10 +17,13 @@ import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
  *
  * @dev All of the core data in this function will be set to private to prevent unintended assignments
  * on inheritting contracts
- *
- * @dev no more pause
  */
-abstract contract PendleGaugeController is IPGaugeController, PermissionsV2Upg {
+
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, PermissionsV2Upg {
     using SafeERC20 for IERC20;
     using Math for uint256;
     using EnumerableSet for EnumerableSet.AddressSet;
@@ -40,6 +43,8 @@ abstract contract PendleGaugeController is IPGaugeController, PermissionsV2Upg {
     mapping(address => MarketRewardData) public rewardData;
     mapping(uint128 => bool) public epochRewardReceived;
 
+    uint256[100] private __gap;
+
     modifier onlyPendleMarket() {
         require(marketFactory.isValidMarket(msg.sender), "invalid market");
         _;

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerMainchain.sol

@@ -1,9 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
-import "./PendleGaugeController.sol";
+import "./PendleGaugeControllerBaseUpg.sol";
 
-contract PendleGaugeControllerMainchain is PendleGaugeController {
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it inherits only upgradable contract
+contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg {
     address public immutable votingController;
 
     modifier onlyVotingController() {
@@ -16,7 +19,7 @@ contract PendleGaugeControllerMainchain is PendleGaugeController {
         address _pendle,
         address _marketFactory,
         address _governanceManager
-    ) PendleGaugeController(_pendle, _marketFactory) PermissionsV2Upg(_governanceManager) {
+    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory) PermissionsV2Upg(_governanceManager) {
         votingController = _votingController;
     }
 

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerSidechain.sol

@@ -1,16 +1,20 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
-import "./PendleGaugeController.sol";
-import "../CelerAbstracts/CelerReceiver.sol";
+import "./PendleGaugeControllerBaseUpg.sol";
+import "../CelerAbstracts/CelerReceiverUpg.sol";
 
 // solhint-disable no-empty-blocks
-contract PendleGaugeControllerSidechain is PendleGaugeController, CelerReceiver {
+
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it inherits only upgradable contract
+contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, CelerReceiverUpg {
     constructor(
         address _pendle,
         address _marketFactory,
         address _governanceManager
-    ) PendleGaugeController(_pendle, _marketFactory) CelerReceiver(_governanceManager) {}
+    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory) CelerReceiverUpg(_governanceManager) {}
 
     function _executeMessage(bytes memory message) internal virtual override {
         (uint128 wTime, address[] memory markets, uint256[] memory pendleAmounts) = abi.decode(

package/contracts/core/LiquidityMining/PendleGauge.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../interfaces/IPGaugeController.sol";
 import "../../interfaces/IPVeToken.sol";

package/contracts/core/LiquidityMining/VotingController/{PendleVotingController.sol → PendleVotingControllerUpg.sol}

@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
-import "./VotingControllerStorage.sol";
-import "../CelerAbstracts/CelerSender.sol";
+import "./VotingControllerStorageUpg.sol";
+import "../CelerAbstracts/CelerSenderUpg.sol";
 import "../../../libraries/VeBalanceLib.sol";
 import "../../../libraries/math/Math.sol";
 import "../../../interfaces/IPGaugeControllerMainchain.sol";
 import "../../../interfaces/IPVotingController.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
 /*
 Voting accounting:
@@ -31,7 +33,16 @@ Cons:
     - Does not guarantee the reward will be distributed on epoch start and end
 */
 
-contract PendleVotingController is CelerSender, VotingControllerStorage, IPVotingController {
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+contract PendleVotingControllerUpg is
+    CelerSenderUpg,
+    VotingControllerStorageUpg,
+    UUPSUpgradeable,
+    IPVotingController
+{
     using VeBalanceLib for VeBalance;
     using Math for uint256;
     using Math for int256;
@@ -39,8 +50,8 @@ contract PendleVotingController is CelerSender, VotingControllerStorage, IPVotin
     using EnumerableSet for EnumerableSet.AddressSet;
 
     constructor(address _vePendle, address _governanceManager)
-        VotingControllerStorage(_vePendle)
-        CelerSender(_governanceManager)
+        VotingControllerStorageUpg(_vePendle) // constructor only set immutable variables
+        CelerSenderUpg(_governanceManager) // constructor only set immutable variables
     {}
 
     /*///////////////////////////////////////////////////////////////
@@ -320,4 +331,6 @@ contract PendleVotingController is CelerSender, VotingControllerStorage, IPVotin
             expiry
         );
     }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyGovernance {}
 }

package/contracts/core/LiquidityMining/VotingController/{VotingControllerStorage.sol → VotingControllerStorageUpg.sol}

@@ -1,17 +1,21 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../../interfaces/IPVeToken.sol";
 import "../../../libraries/VeBalanceLib.sol";
 import "../../../libraries/math/WeekMath.sol";
 import "../../../libraries/helpers/MiniHelpers.sol";
+import "../../../libraries/VeHistoryLib.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-// no reentracy protection yet?
-// Should VotingController and stuff become upgradeable?
-abstract contract VotingControllerStorage {
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+abstract contract VotingControllerStorageUpg {
     using VeBalanceLib for VeBalance;
     using EnumerableSet for EnumerableSet.AddressSet;
+    using Checkpoints for Checkpoints.History;
 
     struct PoolInfo {
         uint64 chainId;
@@ -36,7 +40,7 @@ abstract contract VotingControllerStorage {
         mapping(address => uint128) poolVotes;
     }
 
-    uint128 internal constant MAX_LOCK_TIME = 104 weeks;
+    uint128 public constant MAX_LOCK_TIME = 104 weeks;
     uint64 public constant USER_VOTE_MAX_WEIGHT = 10**18;
     uint128 public constant WEEK = 1 weeks;
     uint128 public constant GOVERNANCE_PENDLE_VOTE = 10**24;
@@ -65,7 +69,9 @@ abstract contract VotingControllerStorage {
     mapping(uint128 => bool) public isEpochFinalized;
 
     // [user][pool] => checkpoint
-    mapping(address => mapping(address => Checkpoint[])) public userPoolCheckpoints;
+    mapping(address => mapping(address => Checkpoints.History)) internal userPoolHistory;
+
+    uint256[100] private __gap;
 
     constructor(address _vePendle) {
         vePendle = IPVeToken(_vePendle);
@@ -104,7 +110,7 @@ abstract contract VotingControllerStorage {
         address pool,
         uint128 timestamp
     ) external view returns (uint128) {
-        return VeBalanceLib.getCheckpointValueAt(userPoolCheckpoints[user][pool], timestamp);
+        return userPoolHistory[user][pool].getAtTimestamp(timestamp);
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -198,9 +204,7 @@ abstract contract VotingControllerStorage {
         address pool,
         VeBalance memory vote
     ) internal {
-        userPoolCheckpoints[user][pool].push(
-            Checkpoint({ balance: vote, timestamp: uint128(block.timestamp) })
-        );
+        userPoolHistory[user][pool].push(vote);
     }
 
     function _setAllPastEpochsAsFinalized() internal {

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -1,16 +1,18 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 import "../../../interfaces/IPVotingEscrow.sol";
 import "../../../libraries/helpers/MiniHelpers.sol";
-import "./VotingEscrowToken.sol";
-import "../CelerAbstracts/CelerSender.sol";
+import "./VotingEscrowTokenBase.sol";
+import "../CelerAbstracts/CelerSenderUpg.sol";
+import "../../../libraries/VeHistoryLib.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
-contract VotingEscrowPendleMainchain is VotingEscrowToken, IPVotingEscrow, CelerSender {
+contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, CelerSenderUpg {
     using SafeERC20 for IERC20;
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
+    using Checkpoints for Checkpoints.History;
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     bytes private constant EMPTY_BYTES = abi.encode();
@@ -26,9 +28,11 @@ contract VotingEscrowPendleMainchain is VotingEscrowToken, IPVotingEscrow, Celer
 
     // Saving VeBalance checkpoint for users of each week, can later use binary search
     // to ask for their vePendle balance at any wTime
-    mapping(address => Checkpoint[]) public userCheckpoints;
+    mapping(address => Checkpoints.History) internal userHistory;
 
-    constructor(IERC20 _pendle, address _governanceManager) CelerSender(_governanceManager) {
+    constructor(IERC20 _pendle, address _governanceManager)
+        CelerSenderUpg(_governanceManager) // only sets immutable variables
+    {
         pendle = _pendle;
     }
 
@@ -132,7 +136,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowToken, IPVotingEscrow, Celer
 
     /// @notice binary search to find balance at a timestamp. This timestamp does not need to be divisible by week
     function getUserVeBalanceAt(address user, uint128 timestamp) external view returns (uint128) {
-        return VeBalanceLib.getCheckpointValueAt(userCheckpoints[user], timestamp);
+        return userHistory[user].getAtTimestamp(timestamp);
     }
 
     /**
@@ -173,7 +177,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowToken, IPVotingEscrow, Celer
 
         _totalSupply = newSupply;
         positionData[user] = newPosition;
-        userCheckpoints[user].push(Checkpoint(newBalance, uint128(block.timestamp)));
+        userHistory[user].push(newBalance);
         return newBalance.getCurrentValue();
     }
 

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../../libraries/VeBalanceLib.sol";
 import "../../../libraries/math/WeekMath.sol";
-import "./VotingEscrowToken.sol";
-import "../CelerAbstracts/CelerReceiver.sol";
+import "./VotingEscrowTokenBase.sol";
+import "../CelerAbstracts/CelerReceiverUpg.sol";
 
 // solhint-disable no-empty-blocks
-contract VotingEscrowPendleSidechain is VotingEscrowToken, CelerReceiver {
+contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg {
     mapping(address => address) internal delegatorOf;
 
     event SetNewDelegator(address delegator, address receiver);
@@ -17,7 +17,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowToken, CelerReceiver {
 
     event SetNewUserPosition(LockedPosition position);
 
-    constructor(address _governanceManager) CelerReceiver(_governanceManager) {}
+    constructor(address _governanceManager) CelerReceiverUpg(_governanceManager) {}
 
     function totalSupplyCurrent() external view virtual override returns (uint128) {
         return totalSupplyStored();

package/contracts/core/LiquidityMining/VotingEscrow/{VotingEscrowToken.sol → VotingEscrowTokenBase.sol}

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../../interfaces/IPVeToken.sol";
 import "../../../libraries/VeBalanceLib.sol";
@@ -19,8 +19,7 @@ import "../../../libraries/helpers/MiniHelpers.sol";
  *        + No other transaction is allowed to write on sidechain storage
  */
 
-abstract contract VotingEscrowToken is IPVeToken {
-    // wrong name, should be VotingEscrowPendle
+abstract contract VotingEscrowTokenBase is IPVeToken {
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
 

package/contracts/core/Market/PendleMarket.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
-import "../PendleERC20.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/ISuperComposableYield.sol";
 import "../../interfaces/IPMarket.sol";
@@ -14,13 +13,13 @@ import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 
 import "../LiquidityMining/PendleGauge.sol";
-import "../PendleERC20Permit.sol";
+import "../PendleERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 // solhint-disable reason-string
 /// Invariances to maintain:
 /// - Internal balances totalPt & totalScy not interferred by people transferring tokens in directly
-contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
+contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     using Math for uint256;
     using Math for int256;
     using MarketMathCore for MarketState;
@@ -66,7 +65,7 @@ contract PendleMarket is PendleERC20Permit, PendleGauge, IPMarket {
         address _vePendle,
         address _gaugeController
     )
-        PendleERC20Permit(NAME, SYMBOL, 18)
+        PendleERC20(NAME, SYMBOL, 18)
         PendleGauge(IPPrincipalToken(_PT).SCY(), _vePendle, _gaugeController)
     {
         PT = IPPrincipalToken(_PT);

package/contracts/core/Market/PendleMarketFactory.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
@@ -7,13 +7,13 @@ import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPYieldContractFactory.sol";
 import "../../interfaces/IPMarketFactory.sol";
 
-import "../../libraries/helpers/MiniDeployer.sol";
+import "../../libraries/helpers/SSTORE2Deployer.sol";
 import "../../periphery/PermissionsV2Upg.sol";
 
 import "./PendleMarket.sol";
 import "../LiquidityMining/PendleGauge.sol";
 
-contract PendleMarketFactory is PermissionsV2Upg, MiniDeployer, Initializable, IPMarketFactory {
+contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory {
     using EnumerableSet for EnumerableSet.AddressSet;
 
     struct MarketConfig {
@@ -28,7 +28,7 @@ contract PendleMarketFactory is PermissionsV2Upg, MiniDeployer, Initializable, I
     uint256 private constant MIN_RATE_ORACLE_TIME_WINDOW = 300 seconds;
 
     address public immutable yieldContractFactory;
-    address public immutable marketCreationCodePointer;
+    address public marketCreationCodePointer;
     uint256 public immutable maxLnFeeRateRoot;
 
     // PT -> scalarRoot -> initialAnchor
@@ -46,8 +46,7 @@ contract PendleMarketFactory is PermissionsV2Upg, MiniDeployer, Initializable, I
         address _treasury,
         uint96 _lnFeeRateRoot,
         uint32 _rateOracleTimeWindow,
-        uint8 _reserveFeePercent,
-        bytes memory _marketCreationCode
+        uint8 _reserveFeePercent
     ) PermissionsV2Upg(_governanceManager) {
         require(_yieldContractFactory != address(0), "zero address");
         yieldContractFactory = _yieldContractFactory;
@@ -57,17 +56,17 @@ contract PendleMarketFactory is PermissionsV2Upg, MiniDeployer, Initializable, I
         setlnFeeRateRoot(_lnFeeRateRoot);
         setRateOracleTimeWindow(_rateOracleTimeWindow);
         setReserveFeePercent(_reserveFeePercent);
-        marketCreationCodePointer = _setCreationCode(_marketCreationCode);
     }
 
-    function initialize(address newVePendle, address newGaugeController)
-        external
-        onlyGovernance
-        initializer
-    {
+    function initialize(
+        address newVePendle,
+        address newGaugeController,
+        bytes memory _marketCreationCode
+    ) external onlyGovernance initializer {
         require(newVePendle != address(0) && newGaugeController != address(0), "zero address");
         vePendle = newVePendle;
         gaugeController = newGaugeController;
+        marketCreationCodePointer = SSTORE2Deployer.setCreationCode(_marketCreationCode);
     }
 
     /**
@@ -80,24 +79,22 @@ contract PendleMarketFactory is PermissionsV2Upg, MiniDeployer, Initializable, I
         int256 initialAnchor
     ) external returns (address market) {
         require(IPYieldContractFactory(yieldContractFactory).isPT(PT), "Invalid PT");
-        require(vePendle != address(0), "vePendle unset");
-        require(gaugeController != address(0), "gaugeController unset");
-        require(
-            markets[PT][scalarRoot][initialAnchor] == address(0),
-            "duplicated creation params"
-        );
+        require(markets[PT][scalarRoot][initialAnchor] == address(0), "market already created");
 
-        market = _deployWithArgs(
+        // no need salt since market's existence has been checked before hand
+        market = SSTORE2Deployer.create2(
             marketCreationCodePointer,
+            bytes32(0),
             abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController)
         );
 
         markets[PT][scalarRoot][initialAnchor] = market;
         require(allMarkets.add(market), "IE market can't be added");
 
-        emit CreateNewMarket(PT, scalarRoot, initialAnchor);
+        emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
     }
 
+    /// @dev for gas-efficient verification of market
     function isValidMarket(address market) external view returns (bool) {
         return allMarkets.contains(market);
     }

package/contracts/core/PendleRouter.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../interfaces/IPYieldToken.sol";
 import "../../interfaces/IPPrincipalToken.sol";

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -1,37 +1,45 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.13;
+pragma solidity 0.8.15;
 
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 
-import "../PendleERC20Permit.sol";
+import "../PendleERC20.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalToken is PendleERC20Permit, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SCY;
-    address public immutable YT;
     address public immutable factory;
     uint256 public immutable expiry;
+    address public YT;
 
     modifier onlyYT() {
         require(msg.sender == address(YT), "ONLY_YT");
         _;
     }
 
+    modifier onlyFactory() {
+        require(msg.sender == factory, "ONLY_FACTORY");
+        _;
+    }
+
     constructor(
         address _SCY,
-        address _YT,
         string memory _name,
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SCY = _SCY;
-        YT = _YT;
         expiry = _expiry;
         factory = msg.sender;
     }
 
+    function initialize(address _YT) external initializer onlyFactory {
+        YT = _YT;
+    }
+
     /**
      * @dev only callable by the YT correspond to this PT
      */