@pendle/core-v2 0.7.1-beta-2 → 0.8.0-beta

package/contracts/core/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -17,25 +17,26 @@ abstract contract VotingControllerStorageUpg {
     using EnumerableSet for EnumerableSet.AddressSet;
     using Checkpoints for Checkpoints.History;
 
-    struct PoolInfo {
+    struct PoolData {
         uint64 chainId;
-        uint128 lastUpdated;
-        VeBalance vote;
+        uint128 lastSlopeChangeAppliedAt;
+        VeBalance totalVote;
         // wTime => slopeChange value
         mapping(uint128 => uint128) slopeChanges;
     }
 
-    struct UserPoolInfo {
+    struct UserPoolData {
         uint64 weight;
         VeBalance vote;
     }
 
     struct UserData {
         uint64 totalVotedWeight;
-        mapping(address => UserPoolInfo) voteForPools;
+        mapping(address => UserPoolData) voteForPools;
     }
 
     struct WeekData {
+        bool isEpochFinalized;
         uint128 totalVotes;
         mapping(address => uint128) poolVotes;
     }
@@ -47,27 +48,26 @@ abstract contract VotingControllerStorageUpg {
 
     IPVeToken public immutable vePendle;
 
+    uint128 public immutable deployedWTime;
+
     uint128 public pendlePerSec;
 
-    uint128 public immutable deployedWTime; // divisible by WEEK
+    EnumerableSet.AddressSet internal allActivePools;
 
-    EnumerableSet.AddressSet internal allPools;
+    EnumerableSet.AddressSet internal allRemovedPools;
 
     // [chainId] => [pool]
     mapping(uint64 => EnumerableSet.AddressSet) internal chainPools;
 
-    // [poolAddress] -> PoolInfo
-    mapping(address => PoolInfo) public poolInfo;
+    // [poolAddress] -> PoolData
+    mapping(address => PoolData) public poolData;
 
     // [wTime] => WeekData
     mapping(uint128 => WeekData) public weekData;
 
-    // user voting info
+    // user voting data
     mapping(address => UserData) public userData;
 
-    // wTime => bool
-    mapping(uint128 => bool) public isEpochFinalized;
-
     // [user][pool] => checkpoint
     mapping(address => mapping(address => Checkpoints.History)) internal userPoolHistory;
 
@@ -83,8 +83,19 @@ abstract contract VotingControllerStorageUpg {
     //////////////////////////////////////////////////////////////*/
 
     /// @dev trivial view function
-    function getAllPools() external view returns (address[] memory) {
-        return allPools.values();
+    function getAllAcitvePools() external view returns (address[] memory) {
+        return allActivePools.values();
+    }
+
+    /// @dev trivial view function
+    function getAllRemovedPools(uint256 start, uint256 end)
+        external
+        view
+        returns (uint256 lengthOfRemovedPools, address[] memory arr)
+    {
+        arr = new address[](end - start + 1);
+        for (uint256 i = start; i <= end; i++) arr[i] = allRemovedPools.at(i);
+        lengthOfRemovedPools = allRemovedPools.length();
     }
 
     /// @dev trivial view function
@@ -96,7 +107,7 @@ abstract contract VotingControllerStorageUpg {
     function getUserPoolVote(address user, address pool)
         external
         view
-        returns (UserPoolInfo memory)
+        returns (UserPoolData memory)
     {
         return userData[user].voteForPools[pool];
     }
@@ -119,26 +130,30 @@ abstract contract VotingControllerStorageUpg {
 
     /**
     * @dev expected behavior:
-        - add to allPools, chainPools
-        - set params in poolInfo
+        - add to allActivePools, chainPools
+        - set params in poolData
      */
     function _addPool(uint64 chainId, address pool) internal {
-        poolInfo[pool].chainId = chainId;
-        poolInfo[pool].lastUpdated = WeekMath.getCurrentWeekStart();
-        require(chainPools[chainId].add(pool), "IE: chainPools duplicated");
-        require(allPools.add(pool), "IE: allPools duplicated");
+        require(chainPools[chainId].add(pool), "IE");
+        require(allActivePools.add(pool), "IE");
+
+        poolData[pool].chainId = chainId;
+        poolData[pool].lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
     }
 
     /**
     * @dev expected behavior:
-        - remove from allPools, chainPools
-        - clear all params in poolInfo
+        - remove from allActivePool, chainPools
+        - add to allRemovedPools
+        - clear all params in poolData
      */
     function _removePool(address pool) internal {
-        uint64 chainId = poolInfo[pool].chainId;
-        require(chainPools[chainId].remove(pool), "IE: chainPools removal failed");
-        require(allPools.remove(pool), "IE: allPools removal failed");
-        delete poolInfo[pool];
+        uint64 chainId = poolData[pool].chainId;
+        require(chainPools[chainId].remove(pool), "IE");
+        require(allActivePools.remove(pool), "IE");
+        require(allRemovedPools.add(pool), "IE");
+
+        delete poolData[pool];
     }
 
     /**
@@ -154,70 +169,62 @@ abstract contract VotingControllerStorageUpg {
         weekData[wTime].poolVotes[pool] = vote;
     }
 
-    function _setNewVotePoolInfo(
+    function _setNewVotePoolData(
         address pool,
         VeBalance memory vote,
         uint128 wTime
     ) internal {
-        poolInfo[pool].vote = vote;
-        poolInfo[pool].lastUpdated = wTime;
-    }
-
-    /// @dev only applicable for current pool, hence no changes for weekData
-    function _subtractVotePoolInfo(address pool, VeBalance memory vote) internal {
-        PoolInfo storage pInfo = poolInfo[pool];
-        pInfo.vote = poolInfo[pool].vote.sub(vote);
-        pInfo.slopeChanges[vote.getExpiry()] -= vote.slope;
-    }
-
-    /// @dev only applicable for current pool, hence no changes for weekData
-    function _addVotePoolInfo(address pool, VeBalance memory vote) internal {
-        PoolInfo storage pInfo = poolInfo[pool];
-        pInfo.vote = poolInfo[pool].vote.add(vote);
-        pInfo.slopeChanges[vote.getExpiry()] += vote.slope;
+        poolData[pool].totalVote = vote;
+        poolData[pool].lastSlopeChangeAppliedAt = wTime;
     }
 
-    function _unsetVoteUserData(address user, address pool) internal {
-        UserData storage uData = userData[user];
-        uData.totalVotedWeight -= uData.voteForPools[pool].weight;
-        delete uData.voteForPools[pool];
-    }
-
-    /// @dev assumption: uData.voteForPools[pool] hasn't been set before
-    /// @dev post-condition: totalVotedWeight <= USER_VOTE_MAX_WEIGHT
-    function _setVoteUserData(
+    function _modifyVoteWeight(
         address user,
         address pool,
-        uint64 weight,
-        VeBalance memory vote
-    ) internal {
+        uint64 weight
+    ) internal returns (VeBalance memory newVote) {
         UserData storage uData = userData[user];
-        uData.totalVotedWeight += weight;
-        require(uData.totalVotedWeight <= USER_VOTE_MAX_WEIGHT, "exceeded max weight");
+        PoolData storage pData = poolData[pool];
+
+        VeBalance memory oldVote = uData.voteForPools[pool].vote;
+
+        // REMOVE OLD VOTE
+        if (oldVote.bias != 0) {
+            if (_isPoolActive(pool) && _isVoteActive(oldVote)) {
+                pData.totalVote = pData.totalVote.sub(oldVote);
+                pData.slopeChanges[oldVote.getExpiry()] -= oldVote.slope;
+            }
+            uData.totalVotedWeight -= uData.voteForPools[pool].weight;
+            delete uData.voteForPools[pool];
+        }
 
-        uData.voteForPools[pool] = UserPoolInfo({ weight: weight, vote: vote });
-    }
+        // ADD NEW VOTE
+        if (weight != 0) {
+            require(_isPoolActive(pool), "pool not active");
 
-    /// @dev post-condition: timestamp is in increasing order (for binary search)
-    function _addUserPoolCheckpoint(
-        address user,
-        address pool,
-        VeBalance memory vote
-    ) internal {
-        userPoolHistory[user][pool].push(vote);
+            newVote = _getVotingPowerByWeight(user, weight);
+
+            pData.totalVote = pData.totalVote.add(newVote);
+            pData.slopeChanges[newVote.getExpiry()] += newVote.slope;
+
+            uData.voteForPools[pool] = UserPoolData(weight, newVote);
+            uData.totalVotedWeight += weight;
+            require(uData.totalVotedWeight <= USER_VOTE_MAX_WEIGHT, "exceeded max weight");
+        }
+
+        userPoolHistory[user][pool].push(newVote);
     }
 
     function _setAllPastEpochsAsFinalized() internal {
         uint128 wTime = WeekMath.getCurrentWeekStart();
-        while (wTime >= deployedWTime && isEpochFinalized[wTime] == false) {
-            isEpochFinalized[wTime] = true;
+        while (wTime >= deployedWTime && weekData[wTime].isEpochFinalized == false) {
+            weekData[wTime].isEpochFinalized = true;
             wTime -= WEEK;
         }
     }
 
-    /// @notice check if a pool is votable on by checking the lastUpdated time
-    function _isPoolVotable(address pool) internal view returns (bool) {
-        return poolInfo[pool].lastUpdated != 0;
+    function _isPoolActive(address pool) internal view returns (bool) {
+        return allActivePools.contains(pool);
     }
 
     /// @notice check if a vote still counts by checking if the vote is not (x,0) (in case the
@@ -225,4 +232,10 @@ abstract contract VotingControllerStorageUpg {
     function _isVoteActive(VeBalance memory vote) internal view returns (bool) {
         return vote.slope != 0 && !MiniHelpers.isCurrentlyExpired(vote.getExpiry());
     }
+
+    function _getVotingPowerByWeight(address user, uint64 weight)
+        internal
+        view
+        virtual
+        returns (VeBalance memory res);
 }

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

@@ -52,7 +52,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev expected state changes:
         - a new lock with amount = amountToPull + amountExpired, expiry = expiry is created for msg.sender in positionData
         - pendle is taken in if necessary
-        - _totalSupply, lastSupplyUpdatedAt, slopeChanges, totalSupplyAt is updated
+        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt is updated
         - a checkpoint is added
      * @dev broadcast is not bundled since it can be done anytime after
      */
@@ -87,13 +87,14 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev expected state changes:
         - positionData is cleared
         - pendle is transferred out
-        - _totalSupply, lastSupplyUpdatedAt, slopeChanges, totalSupplyAt all doesn't need to be updated
-            since these data will automatically hold true when _updateTotalSupply() is called
+        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt all doesn't need to be updated
+            since these data will automatically hold true when _applySlopeChange() is called
         - no checkpoint is added
      * @dev broadcast is not bundled since it can be done anytime after
      */
-    function withdraw(address user) external returns (uint128 amount) {
-        require(isPositionExpired(user), "position not expired");
+    function withdraw() external returns (uint128 amount) {
+        address user = msg.sender;
+        require(_isPositionExpired(user), "position not expired");
         amount = positionData[user].amount;
 
         require(amount > 0, "zero position");
@@ -108,10 +109,10 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     /**
      * @notice update & return the current totalSupply
      * @dev state changes expected:
-        - _totalSupply & lastSupplyUpdatedAt is updated
+        - _totalSupply & lastSlopeChangeAppliedAt is updated
      */
     function totalSupplyCurrent() external virtual override returns (uint128) {
-        (VeBalance memory supply, ) = _updateTotalSupply();
+        (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }
 
@@ -146,7 +147,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
       * @dev expected state changes:
         - a new lock with the amount & expiry increase accordingly
         - pendle is taken in if necessary
-        - _totalSupply, lastSupplyUpdatedAt, slopeChanges, totalSupplyAt is updated
+        - _totalSupply, lastSlopeChangeAppliedAt, slopeChanges, totalSupplyAt is updated
         - a checkpoint is added
      */
     function _increasePosition(
@@ -156,7 +157,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     ) internal returns (uint128) {
         LockedPosition memory oldPosition = positionData[user];
 
-        (VeBalance memory newSupply, ) = _updateTotalSupply();
+        (VeBalance memory newSupply, ) = _applySlopeChange();
 
         if (!MiniHelpers.isCurrentlyExpired(oldPosition.expiry)) {
             // remove old position not yet expired
@@ -185,11 +186,11 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @notice update the totalSupply, processing all slope changes of past weeks. At the same time, set the finalized
         totalSupplyAt
      * @dev state changes expected:
-        - _totalSupply, lastSupplyUpdatedAt, totalSupplyAt is updated
+        - _totalSupply, lastSlopeChangeAppliedAt, totalSupplyAt is updated
      */
-    function _updateTotalSupply() internal returns (VeBalance memory, uint128) {
+    function _applySlopeChange() internal returns (VeBalance memory, uint128) {
         VeBalance memory supply = _totalSupply;
-        uint128 wTime = lastSupplyUpdatedAt;
+        uint128 wTime = lastSlopeChangeAppliedAt;
         uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
 
         if (wTime >= currentWeekStart) {
@@ -203,16 +204,16 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         }
 
         _totalSupply = supply;
-        lastSupplyUpdatedAt = wTime;
+        lastSlopeChangeAppliedAt = wTime;
 
-        return (supply, lastSupplyUpdatedAt);
+        return (supply, lastSlopeChangeAppliedAt);
     }
 
     /// @notice broadcast position to all chains in chainIds
     function _broadcastPosition(address user, uint256[] calldata chainIds) public payable {
         require(chainIds.length != 0, "empty chainIds");
 
-        (VeBalance memory supply, uint256 wTime) = _updateTotalSupply();
+        (VeBalance memory supply, uint256 wTime) = _applySlopeChange();
 
         bytes memory userData = (
             user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
@@ -230,7 +231,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     }
 
     function _afterAddSidechainContract(address, uint256 chainId) internal virtual override {
-        (VeBalance memory supply, uint256 wTime) = _updateTotalSupply();
+        (VeBalance memory supply, uint256 wTime) = _applySlopeChange();
         _broadcast(chainId, wTime, supply, EMPTY_BYTES);
     }
 

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

@@ -58,7 +58,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
 
     function _setNewTotalSupply(uint128 wTime, VeBalance memory supply) internal {
         assert(wTime == WeekMath.getWeekStartTimestamp(wTime));
-        lastSupplyUpdatedAt = wTime;
+        lastSlopeChangeAppliedAt = wTime;
         _totalSupply = supply;
         emit SetNewTotalSupply(supply);
     }

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

@@ -27,16 +27,15 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
 
     VeBalance internal _totalSupply;
-    uint128 public lastSupplyUpdatedAt;
+    uint128 public lastSlopeChangeAppliedAt;
 
     mapping(address => LockedPosition) public positionData;
 
     constructor() {
-        lastSupplyUpdatedAt = WeekMath.getCurrentWeekStart();
+        lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
     }
 
     function balanceOf(address user) public view virtual returns (uint128) {
-        if (isPositionExpired(user)) return 0;
         return positionData[user].convertToVeBalance().getCurrentValue();
     }
 
@@ -46,7 +45,7 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
 
     function totalSupplyCurrent() external virtual returns (uint128);
 
-    function isPositionExpired(address user) public view returns (bool) {
+    function _isPositionExpired(address user) internal view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(positionData[user].expiry);
     }
 }

package/contracts/core/Market/PendleMarket.sol

@@ -1,24 +1,27 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
+import "../PendleERC20.sol";
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/ISuperComposableYield.sol";
 import "../../interfaces/IPMarket.sol";
 import "../../interfaces/IPMarketFactory.sol";
 import "../../interfaces/IPMarketSwapCallback.sol";
-import "../../interfaces/IPMarketAddRemoveCallback.sol";
 
 import "../../libraries/math/LogExpMath.sol";
 import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 
 import "../LiquidityMining/PendleGauge.sol";
-import "../PendleERC20.sol";
+import "../PendleERC20Permit.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
+/**
+Invariances to maintain:
+- Internal balances totalPt & totalScy not interferred 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 PendleMarket is PendleERC20, PendleGauge, IPMarket {
     using Math for uint256;
     using Math for int256;
@@ -36,9 +39,6 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         // 1 SLOT = 224 bits
     }
 
-    uint8 private constant _NOT_ENTERED = 1;
-    uint8 private constant _ENTERED = 2;
-
     string private constant NAME = "Pendle Market";
     string private constant SYMBOL = "PENDLE-LPT";
 
@@ -81,29 +81,24 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
     /**
      * @notice PendleMarket allows users to provide in PT & SCY in exchange for LPs, which
-     * will grant LP holders more exchange fee over time. All the tokens must be transferred to
-     * this market prior to the call for LP to be minted. There is no flashAdd
-     * @param data bytes data to be sent in the callback
+     * will grant LP holders more exchange fee over time
      */
-    function addLiquidity(
-        address receiver,
-        uint256 scyDesired,
-        uint256 ptDesired,
-        bytes calldata data
-    )
+    function mint(address receiver)
         external
         nonReentrant
         notExpired
-        returns (
-            uint256 lpToAccount,
-            uint256 scyUsed,
-            uint256 ptUsed
-        )
+        returns (uint256 lpToAccount)
     {
         MarketState memory market = readState(true);
         SCYIndex index = SCY.newIndex();
 
+        uint256 scyDesired = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
+        uint256 ptDesired = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
+
         uint256 lpToReserve;
+        uint256 scyUsed;
+        uint256 ptUsed;
+
         (lpToReserve, lpToAccount, scyUsed, ptUsed) = market.addLiquidity(
             index,
             scyDesired,
@@ -121,39 +116,23 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)));
-        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
-
-        emit AddLiquidity(receiver, lpToAccount, scyUsed, ptUsed);
-
-        // no flashAdd, we only do callback after all the tokens have been provided
-        if (data.length > 0) {
-            IPMarketAddRemoveCallback(msg.sender).addLiquidityCallback(
-                lpToAccount,
-                scyUsed,
-                ptUsed,
-                data
-            );
-        }
+        emit Mint(receiver, lpToAccount, scyUsed, ptUsed);
     }
 
     /**
      * @notice LP Holders can burn their LP to receive back SCY & PT proportionally
      * to their share of market
-     * @dev steps working of this contract
-       - SCY & PT will be first transferred out to receiver
-       - Callback to msg.sender if data.length > 0
-       - Ensure the corresponding amount of LP has been transferred to this contract
-     * @param data bytes data to be sent in the callback
      */
-    function removeLiquidity(
-        address receiverScy,
-        address receiverPt,
-        uint256 lpToRemove,
-        bytes calldata data
-    ) external nonReentrant returns (uint256 scyToAccount, uint256 ptToAccount) {
+    function burn(address receiverScy, address receiverPt)
+        external
+        nonReentrant
+        returns (uint256 scyToAccount, uint256 ptToAccount)
+    {
         MarketState memory market = readState(true);
 
+        uint256 lpToRemove = balanceOf(address(this));
+        _burn(address(this), lpToRemove);
+
         (scyToAccount, ptToAccount) = market.removeLiquidity(lpToRemove, true);
 
         IERC20(SCY).safeTransfer(receiverScy, scyToAccount);
@@ -161,19 +140,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
 
         _writeState(market);
 
-        if (data.length > 0) {
-            IPMarketAddRemoveCallback(msg.sender).removeLiquidityCallback(
-                lpToRemove,
-                scyToAccount,
-                ptToAccount,
-                data
-            );
-        }
-
-        // this checks enough lp has been transferred in
-        _burn(address(this), lpToRemove);
-
-        emit RemoveLiquidity(receiverScy, receiverPt, lpToRemove, scyToAccount, ptToAccount);
+        emit Burn(receiverScy, receiverPt, lpToRemove, scyToAccount, ptToAccount);
     }
 
     /**
@@ -209,7 +176,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         }
 
         // have received enough PT
-        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)));
+        require(market.totalPt.Uint() <= IERC20(PT).balanceOf(address(this)), "insufficient PT");
 
         emit Swap(receiver, exactPtIn.neg(), netScyOut.Int(), netScyToReserve);
     }
@@ -246,7 +213,10 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         }
 
         // have received enough SCY
-        require(market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)));
+        require(
+            market.totalScy.Uint() <= IERC20(SCY).balanceOf(address(this)),
+            "insufficient SCY"
+        );
 
         emit Swap(receiver, exactPtOut.Int(), netScyIn.neg(), netScyToReserve);
     }

package/contracts/core/PendleRouter.sol

@@ -56,7 +56,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, PermissionsV2Upg
             sig == IPActionCore.swapExactScyForPt.selector ||
             sig == IPActionCore.swapExactRawTokenForPt.selector ||
             sig == IPActionCore.swapExactPtForRawToken.selector ||
-            sig == IPActionCore.redeemDueIncome.selector
+            sig == IPActionCore.redeemDueInterestAndRewards.selector
         ) {
             return ACTION_CORE;
         } else if (

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -37,10 +37,11 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
     }
 
     function _distributeInterestForTwo(address user1, address user2) internal {
-        // no updateRewardIndex since we rely on SCY's rewardIndexes
         uint256 index = _getInterestIndex();
-        if (user1 != address(0) && user1 != address(this)) _distributeInterest(user1, index);
-        if (user2 != address(0) && user2 != address(this)) _distributeInterest(user2, index);
+        if (user1 != address(0) && user1 != address(this))
+            _distributeInterestPrivate(user1, index);
+        if (user2 != address(0) && user2 != address(this))
+            _distributeInterestPrivate(user2, index);
     }
 
     function _doTransferOutInterest(
@@ -48,13 +49,12 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
         address SCY,
         address factory
     ) internal returns (uint256 interestAmount) {
-        uint256 interestPreFee = userInterest[user].accrued;
-        userInterest[user].accrued = 0;
-
         address treasury = IPYieldContractFactory(factory).treasury();
-
         uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
 
+        uint256 interestPreFee = userInterest[user].accrued;
+        userInterest[user].accrued = 0;
+
         uint256 feeAmount = interestPreFee.mulDown(feeRate);
         interestAmount = interestPreFee - feeAmount;
 
@@ -62,7 +62,10 @@ abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
         _transferOut(SCY, user, interestAmount);
     }
 
-    function _distributeInterest(address user, uint256 currentIndex) private {
+    // should only be callable from `_distributeInterestForTwo` & make sure user != address(0) && user != address(this)
+    function _distributeInterestPrivate(address user, uint256 currentIndex) private {
+        assert(user != address(0) && user != address(this));
+
         uint256 prevIndex = userInterest[user].index;
 
         if (prevIndex == currentIndex) return;

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,11 +4,11 @@ pragma solidity 0.8.15;
 import "../../interfaces/IPPrincipalToken.sol";
 import "../../interfaces/IPYieldToken.sol";
 
-import "../PendleERC20.sol";
+import "../PendleERC20Permit.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
     address public immutable SCY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -30,7 +30,7 @@ contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20(_name, _symbol, __decimals) {
+    ) PendleERC20Permit(_name, _symbol, __decimals) {
         SCY = _SCY;
         expiry = _expiry;
         factory = msg.sender;