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

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

@@ -59,98 +59,90 @@ contract PendleVotingControllerUpg is
     //////////////////////////////////////////////////////////////*/
 
     /**
-     * @notice set a new voting weight for the target pool
-     * @dev pre-condition:
-        - pool must have been added before
-        - the vePENDLE position must still be active
      * @dev state changes expected:
         - update weekData (if any)
-        - update poolInfo, userData to reflect the new vote
-        - add 1 check point for both the unvote & new vote
+        - update poolData, userData to reflect the new vote
+        - add 1 check point for each of pools
      * @dev vePENDLE position not expired is a must, else bias - t*slope < 0 & it will be
         negative weight
      */
-    function vote(address pool, uint64 weight) external {
+    function vote(address[] calldata pools, uint64[] calldata weights) external {
         address user = msg.sender;
 
-        require(weight != 0, "zero weight");
-        require(_isPoolVotable(pool), "invalid pool");
-        require(!vePendle.isPositionExpired(user), "user position expired");
+        require(weights.length == pools.length, "invaid array length");
+        require(vePendle.balanceOf(user) > 0, "zero vependle balance");
 
-        updatePoolVotes(pool);
-        _unvote(user, pool, false);
-        _vote(user, pool, weight);
-    }
+        UserData storage uData = userData[user];
 
-    /**
-     * @notice remove the vote from the current pool
-     * @dev no pre-condition as opposed to vote since this function is to clear the vote
-     * @dev allow removing vote from a non-votable pool BY not requiring pool to be votable
-     * @dev state changes expected:
-        - update weekData (if any)
-        - update poolInfo, userData to reflect the new vote
-        - add 1 check point for the unvote
-     */
-    function unvote(address pool) external {
-        if (_isPoolVotable(pool)) {
-            updatePoolVotes(pool);
+        for (uint256 i = 0; i < pools.length; ++i) {
+            if (_isPoolActive(pools[i])) applyPoolSlopeChanges(pools[i]);
+        }
+
+        for (uint256 i = 0; i < pools.length; ++i) {
+            if (uData.voteForPools[pools[i]].weight <= weights[i])
+                _modifyVoteWeight(user, pools[i], weights[i]);
+        }
+
+        for (uint256 i = 0; i < pools.length; ++i) {
+            if (uData.voteForPools[pools[i]].weight > weights[i])
+                _modifyVoteWeight(user, pools[i], weights[i]);
         }
-        _unvote(msg.sender, pool, true);
     }
 
     /**
      * @notice Process all the slopeChanges that haven't been processed & update these data into
-        poolInfo
-     * @dev pre-condition: the pool must be votable
+        poolData
+     * @dev pre-condition: the pool must be active
      * @dev state changes expected:
         - update weekData
-        - update poolInfo
+        - update poolData
      */
-    function updatePoolVotes(address pool) public {
-        require(_isPoolVotable(pool), "invalid pool");
+    function applyPoolSlopeChanges(address pool) public {
+        require(_isPoolActive(pool), "invalid pool");
 
-        uint128 wTime = poolInfo[pool].lastUpdated;
+        uint128 wTime = poolData[pool].lastSlopeChangeAppliedAt;
         uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
 
         // no state changes are expected
         if (wTime >= currentWeekStart) return;
 
-        VeBalance memory currentVote = poolInfo[pool].vote;
+        VeBalance memory currentVote = poolData[pool].totalVote;
         while (wTime < currentWeekStart) {
             wTime += WEEK;
-            currentVote = currentVote.sub(poolInfo[pool].slopeChanges[wTime], wTime);
+            currentVote = currentVote.sub(poolData[pool].slopeChanges[wTime], wTime);
             _setFinalPoolVoteForWeek(pool, wTime, currentVote.getValueAt(wTime));
         }
 
-        _setNewVotePoolInfo(pool, currentVote, wTime);
+        _setNewVotePoolData(pool, currentVote, wTime);
     }
 
     /**
      * @notice finalize the voting results of all pools, up to the current epoch
      * @dev state changes expected:
-        - weekData, poolInfo is updated for all pools in allPools
+        - weekData, poolData is updated for all pools in allActivePools
         - isEpochFinalized is set to true for all epochs since the last time until now
-     * @dev this function might take a lot of gas, but can be mitigated by calling updatePoolVotes
+     * @dev this function might take a lot of gas, but can be mitigated by calling applyPoolSlopeChanges
         separately, hence reduce the number of states to be updated
      */
     function finalizeEpoch() public {
-        uint256 length = allPools.length();
+        uint256 length = allActivePools.length();
         for (uint256 i = 0; i < length; ++i) {
-            updatePoolVotes(allPools.at(i));
+            applyPoolSlopeChanges(allActivePools.at(i));
         }
         _setAllPastEpochsAsFinalized();
     }
 
     /**
      * @notice broadcast the voting results of the current week to the chain with chainId. Can be
-        called by anyone
+        called by anyone. It's intentional to allow the same results to be broadcasted multiple
+        times. The receiver should be able to filter these duplicated messages
      * @dev pre-condition: the epoch must have already been finalized by finalizeEpoch
      * @dev state changes expected:
         - the gaugeController receives the new pendle allocation
      */
     function broadcastResults(uint64 chainId) external payable {
         uint128 wTime = WeekMath.getCurrentWeekStart();
-        require(isEpochFinalized[wTime], "epoch not finalized");
+        require(weekData[wTime].isEpochFinalized, "epoch not finalized");
         _broadcastResults(chainId, wTime, pendlePerSec);
     }
 
@@ -163,11 +155,13 @@ contract PendleVotingControllerUpg is
      * @dev pre-condition: pool must not have been added before
      * @dev assumption: chainId is valid, pool does exist on the chain (guaranteed by gov)
      * @dev state changes expected:
-        - add to allPools & chainPools
-        - set params in poolInfo
+        - add to allActivePools & chainPools
+        - set params in poolData
      */
     function addPool(uint64 chainId, address pool) external onlyGovernance {
-        require(!_isPoolVotable(pool), "pool already added");
+        require(!_isPoolActive(pool), "pool already added");
+        require(!allRemovedPools.contains(pool), "not allowed to add a removed pool");
+
         _addPool(chainId, pool);
         emit AddPool(chainId, pool);
     }
@@ -177,14 +171,15 @@ contract PendleVotingControllerUpg is
      * @dev pre-condition: pool must have been added before
      * @dev state changes expected:
         - update weekData (if any)
-        - remove from allPools & chainPools
-        - clear info in poolInfo
+        - remove from allActivePools & chainPools
+        - clear data in poolData
      */
     function removePool(address pool) external onlyGovernance {
-        require(_isPoolVotable(pool), "invalid pool");
-        uint64 chainId = poolInfo[pool].chainId;
+        require(_isPoolActive(pool), "invalid pool");
+
+        uint64 chainId = poolData[pool].chainId;
 
-        updatePoolVotes(pool);
+        applyPoolSlopeChanges(pool);
         _removePool(pool);
 
         emit RemovePool(chainId, pool);
@@ -222,7 +217,7 @@ contract PendleVotingControllerUpg is
 
     /**
      * @notice broadcast voting results of the timestamp to chainId
-     * @dev assumption: the epoch is already finalized, lastUpdated of all pools >= currentWeekTimestamp
+     * @dev assumption: the epoch is already finalized, lastSlopeChangeAppliedAt of all pools >= currentWeekTimestamp
      * @dev state changes expected:
         - the gaugeController receives the new pendle allocation
      */
@@ -260,51 +255,6 @@ contract PendleVotingControllerUpg is
         emit BroadcastResults(chainId, wTime, totalPendlePerSec);
     }
 
-    /**
-     * @notice remove the vote from the current pool
-     * @dev state changes expected:
-        - vote in poolInfo is cleared if the vote is still valid
-        - update UserData to remove the vote weight
-        - add a check-point if required
-     */
-    function _unvote(
-        address user,
-        address pool,
-        bool doCreateCheckpoint
-    ) internal {
-        VeBalance memory oldUVote = userData[user].voteForPools[pool].vote;
-        if (_isPoolVotable(pool) && _isVoteActive(oldUVote)) {
-            _subtractVotePoolInfo(pool, oldUVote);
-        }
-        _unsetVoteUserData(user, pool);
-
-        if (doCreateCheckpoint) {
-            _addUserPoolCheckpoint(user, pool, VeBalance(0, 0));
-        }
-        emit Unvote(user, pool, oldUVote);
-    }
-
-    /**
-     * @notice remove the vote from the current pool
-     * @dev there must not be any current vote on this pool by the user
-     * @dev state changes expected:
-        - vote in poolInfo is added
-        - update UserData to set the new vote weight
-        - add a check-point
-     */
-    function _vote(
-        address user,
-        address pool,
-        uint64 weight
-    ) internal {
-        VeBalance memory votingPower = _getVotingPowerByWeight(user, weight);
-        _addVotePoolInfo(pool, votingPower);
-        _setVoteUserData(user, pool, weight, votingPower);
-        _addUserPoolCheckpoint(user, pool, votingPower);
-
-        emit Vote(user, pool, weight, votingPower);
-    }
-
     /**
      * @notice return the corresponding voting power of an user given the weight. Basically his voting power
         will be vePendle * weight / USER_VOTE_MAX_WEIGHT
@@ -314,6 +264,7 @@ contract PendleVotingControllerUpg is
         internal
         view
         virtual
+        override
         returns (VeBalance memory res)
     {
         uint128 amount;

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