@pendle/core-v2 0.8.0-beta-12 → 0.8.1-gamma

package/contracts/core/LiquidityMining/PendleGauge.sol

@@ -80,8 +80,9 @@ abstract contract PendleGauge is RewardManager {
         virtual
         returns (uint256)
     {
-        uint256 vePendleBalance = vePENDLE.balanceOf(user);
-        uint256 vePendleSupply = vePENDLE.totalSupplyCurrent();
+        (uint256 vePendleBalance, uint256 vePendleSupply) = vePENDLE.totalSupplyAndBlanaceCurrent(
+            user
+        );
         // Inspired by Curve's Gauge
         uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
         if (vePendleSupply > 0) {

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

@@ -73,20 +73,28 @@ contract PendleVotingControllerUpg is
         require(vePendle.balanceOf(user) > 0, "zero vependle balance");
 
         UserData storage uData = userData[user];
+        LockedPosition memory userPosition = _getUserVePendlePosition(user);
 
         for (uint256 i = 0; i < pools.length; ++i) {
             if (_isPoolActive(pools[i])) applyPoolSlopeChanges(pools[i]);
         }
 
+        // Process weight-decrease pools first
         for (uint256 i = 0; i < pools.length; ++i) {
-            if (uData.voteForPools[pools[i]].weight <= weights[i])
-                _modifyVoteWeight(user, pools[i], weights[i]);
+            if (uData.voteForPools[pools[i]].weight > weights[i])
+                _modifyVoteWeight(user, pools[i], userPosition, weights[i]);
         }
 
+        // Process weight-increase pools
         for (uint256 i = 0; i < pools.length; ++i) {
-            if (uData.voteForPools[pools[i]].weight > weights[i])
-                _modifyVoteWeight(user, pools[i], weights[i]);
+            if (uData.voteForPools[pools[i]].weight <= weights[i])
+                _modifyVoteWeight(user, pools[i], userPosition, weights[i]);
         }
+
+        require(
+            uData.totalVotedWeight <= VeBalanceLib.USER_VOTE_MAX_WEIGHT,
+            "exceeded max weight"
+        );
     }
 
     /**
@@ -140,7 +148,7 @@ contract PendleVotingControllerUpg is
      * @dev state changes expected:
         - the gaugeController receives the new pendle allocation
      */
-    function broadcastResults(uint64 chainId) external payable {
+    function broadcastResults(uint64 chainId) external payable refundUnusedEth {
         uint128 wTime = WeekMath.getCurrentWeekStart();
         require(weekData[wTime].isEpochFinalized, "epoch not finalized");
         _broadcastResults(chainId, wTime, pendlePerSec);
@@ -157,6 +165,8 @@ contract PendleVotingControllerUpg is
      * @dev state changes expected:
         - add to allActivePools & chainPools
         - set params in poolData
+     * @dev NOTE TO GOV: previous week's results should have been broadcasted prior to calling
+      this function
      */
     function addPool(uint64 chainId, address pool) external onlyGovernance {
         require(!_isPoolActive(pool), "pool already added");
@@ -173,6 +183,8 @@ contract PendleVotingControllerUpg is
         - update weekData (if any)
         - remove from allActivePools & chainPools
         - clear data in poolData
+     * @dev NOTE TO GOV: previous week's results should have been broadcasted prior to calling
+      this function
      */
     function removePool(address pool) external onlyGovernance {
         require(_isPoolActive(pool), "invalid pool");
@@ -197,7 +209,7 @@ contract PendleVotingControllerUpg is
         uint64 chainId,
         uint128 wTime,
         uint128 forcedPendlePerSec
-    ) external payable onlyGovernance {
+    ) external payable onlyGovernance refundUnusedEth {
         _broadcastResults(chainId, wTime, forcedPendlePerSec);
     }
 
@@ -205,12 +217,26 @@ contract PendleVotingControllerUpg is
      * @notice set new pendlePerSec
      * @dev no zero checks because gov may want to stop liquidity mining
      * @dev state changes expected: pendlePerSec is updated
+     * @dev NOTE TO GOV: This should be done mid-week, well before the next broadcast to avoid
+        race condition
      */
     function setPendlePerSec(uint128 newPendlePerSec) external onlyGovernance {
         pendlePerSec = newPendlePerSec;
         emit SetPendlePerSec(newPendlePerSec);
     }
 
+    function getBroadcastResultFee(uint64 chainId) external view returns (uint256) {
+        if (chainId == block.chainid) return 0; // Mainchain broadcast
+
+        uint256 length = chainPools[chainId].length();
+        if (length == 0) return 0;
+
+        address[] memory pools = new address[](length);
+        uint256[] memory totalPendleAmounts = new uint256[](length);
+
+        return celerMessageBus.calcFee(abi.encode(uint128(0), pools, totalPendleAmounts));
+    }
+
     /*///////////////////////////////////////////////////////////////
                     INTERNAL FUNCTIONS
     //////////////////////////////////////////////////////////////*/
@@ -237,12 +263,11 @@ contract PendleVotingControllerUpg is
 
         for (uint256 i = 0; i < length; ++i) {
             uint256 poolVotes = weekData[wTime].poolVotes[pools[i]];
-            uint256 pendlePerSec = (uint256(totalPendlePerSec) * poolVotes) / totalVotes;
-            totalPendleAmounts[i] = pendlePerSec * WEEK;
+            totalPendleAmounts[i] = (totalPendlePerSec * poolVotes * WEEK) / totalVotes;
         }
 
         if (chainId == block.chainid) {
-            address gaugeController = sidechainContracts.get(uint256(chainId));
+            address gaugeController = destinationContracts.get(chainId);
             IPGaugeControllerMainchain(gaugeController).updateVotingResults(
                 wTime,
                 pools,
@@ -255,32 +280,19 @@ contract PendleVotingControllerUpg is
         emit BroadcastResults(chainId, wTime, totalPendlePerSec);
     }
 
-    /**
-     * @notice return the corresponding voting power of an user given the weight. Basically his voting power
-        will be vePendle * weight / USER_VOTE_MAX_WEIGHT
-     * @notice governance will always has the vePendle equivalent to 1M PENDLE locked for MAX_LOCK_TIME
-     */
-    function _getVotingPowerByWeight(address user, uint64 weight)
+    function _getUserVePendlePosition(address user)
         internal
         view
-        virtual
-        override
-        returns (VeBalance memory res)
+        returns (LockedPosition memory userPosition)
     {
-        uint128 amount;
-        uint128 expiry;
-
         if (user == _governance()) {
-            amount = GOVERNANCE_PENDLE_VOTE;
-            expiry = WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME);
+            (userPosition.amount, userPosition.expiry) = (
+                GOVERNANCE_PENDLE_VOTE,
+                WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME)
+            );
         } else {
-            (amount, expiry) = vePendle.positionData(user);
+            (userPosition.amount, userPosition.expiry) = vePendle.positionData(user);
         }
-
-        (res.bias, res.slope) = VeBalanceLib.convertToVeBalance(
-            uint128((uint256(amount) * weight) / USER_VOTE_MAX_WEIGHT),
-            expiry
-        );
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyGovernance {}

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

@@ -14,6 +14,7 @@ import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 /// - it inherits only upgradable contract
 abstract contract VotingControllerStorageUpg {
     using VeBalanceLib for VeBalance;
+    using VeBalanceLib for LockedPosition;
     using EnumerableSet for EnumerableSet.AddressSet;
     using Checkpoints for Checkpoints.History;
 
@@ -42,7 +43,6 @@ abstract contract VotingControllerStorageUpg {
     }
 
     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;
 
@@ -181,6 +181,7 @@ abstract contract VotingControllerStorageUpg {
     function _modifyVoteWeight(
         address user,
         address pool,
+        LockedPosition memory userPosition,
         uint64 weight
     ) internal returns (VeBalance memory newVote) {
         UserData storage uData = userData[user];
@@ -202,14 +203,13 @@ abstract contract VotingControllerStorageUpg {
         if (weight != 0) {
             require(_isPoolActive(pool), "pool not active");
 
-            newVote = _getVotingPowerByWeight(user, weight);
+            newVote = userPosition.convertToVeBalance(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);
@@ -217,7 +217,7 @@ abstract contract VotingControllerStorageUpg {
 
     function _setAllPastEpochsAsFinalized() internal {
         uint128 wTime = WeekMath.getCurrentWeekStart();
-        while (wTime >= deployedWTime && weekData[wTime].isEpochFinalized == false) {
+        while (wTime > deployedWTime && weekData[wTime].isEpochFinalized == false) {
             weekData[wTime].isEpochFinalized = true;
             wTime -= WEEK;
         }
@@ -232,10 +232,4 @@ 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

@@ -16,6 +16,10 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     bytes private constant EMPTY_BYTES = abi.encode();
+    bytes private constant SAMPLE_SUPPLY_UPDATE_MESSAGE =
+        abi.encode(0, VeBalance(0, 0), EMPTY_BYTES);
+    bytes private constant SAMPLE_POSITION_UPDATE_MESSAGE =
+        abi.encode(0, VeBalance(0, 0), abi.encode(address(0), LockedPosition(0, 0)));
 
     IERC20 public immutable pendle;
 
@@ -41,7 +45,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         uint128 additionalAmountToLock,
         uint128 newExpiry,
         uint256[] calldata chainIds
-    ) external payable returns (uint128 newVeBalance) {
+    ) external payable refundUnusedEth returns (uint128 newVeBalance) {
         newVeBalance = increaseLockPosition(additionalAmountToLock, newExpiry);
         broadcastUserPosition(msg.sender, chainIds);
     }
@@ -67,6 +71,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         );
 
         require(newExpiry <= block.timestamp + MAX_LOCK_TIME, "max lock time exceeded");
+        require(positionData[user].expiry <= newExpiry, "new expiry must be after current expiry");
 
         uint128 newTotalAmountLocked = additionalAmountToLock + positionData[user].amount;
         require(newTotalAmountLocked > 0, "zero total amount locked");
@@ -77,7 +82,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
             pendle.safeTransferFrom(user, address(this), additionalAmountToLock);
         }
 
-        newVeBalance = _increasePosition(user, additionalDurationToLock, additionalAmountToLock);
+        newVeBalance = _increasePosition(user, additionalAmountToLock, additionalDurationToLock);
 
         emit NewLockPosition(user, newTotalAmountLocked, newExpiry);
     }
@@ -111,7 +116,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - _totalSupply & lastSlopeChangeAppliedAt is updated
      */
-    function totalSupplyCurrent() external virtual override returns (uint128) {
+    function totalSupplyCurrent() public virtual override returns (uint128) {
         (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }
@@ -121,7 +126,7 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - all chains in chainIds receive the new totalSupply
      */
-    function broadcastTotalSupply(uint256[] calldata chainIds) public payable {
+    function broadcastTotalSupply(uint256[] calldata chainIds) public payable refundUnusedEth {
         _broadcastPosition(address(0), chainIds);
     }
 
@@ -130,7 +135,11 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      * @dev state changes expected:
         - all chains in chainIds receive the new totalSupply & user's new position
      */
-    function broadcastUserPosition(address user, uint256[] calldata chainIds) public payable {
+    function broadcastUserPosition(address user, uint256[] calldata chainIds)
+        public
+        payable
+        refundUnusedEth
+    {
         require(user != address(0), "zero address user");
         _broadcastPosition(user, chainIds);
     }
@@ -140,6 +149,14 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         return userHistory[user].getAtTimestamp(timestamp);
     }
 
+    function getBroadcastSupplyFee(uint256[] calldata chainIds) external view returns (uint256) {
+        return celerMessageBus.calcFee(SAMPLE_SUPPLY_UPDATE_MESSAGE) * chainIds.length;
+    }
+
+    function getBroadcastPositionFee(uint256[] calldata chainIds) external view returns (uint256) {
+        return celerMessageBus.calcFee(SAMPLE_POSITION_UPDATE_MESSAGE) * chainIds.length;
+    }
+
     /**
      * @notice increase the locking position of the user
      * @dev it works by simply removing the old position from all relevant data (as if the user has never locked) and
@@ -152,8 +169,8 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
      */
     function _increasePosition(
         address user,
-        uint128 durationToIncrease,
-        uint128 amountToIncrease
+        uint128 amountToIncrease,
+        uint128 durationToIncrease
     ) internal returns (uint128) {
         LockedPosition memory oldPosition = positionData[user];
 
@@ -206,38 +223,38 @@ contract VotingEscrowPendleMainchain is IPVotingEscrow, VotingEscrowTokenBase, C
         _totalSupply = supply;
         lastSlopeChangeAppliedAt = wTime;
 
-        return (supply, lastSlopeChangeAppliedAt);
+        return (supply, wTime);
     }
 
     /// @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) = _applySlopeChange();
+        (VeBalance memory supply, uint128 wTime) = _applySlopeChange();
 
         bytes memory userData = (
             user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
         );
 
         for (uint256 i = 0; i < chainIds.length; ++i) {
-            require(sidechainContracts.contains(chainIds[i]), "not supported chain");
+            require(destinationContracts.contains(chainIds[i]), "not supported chain");
             _broadcast(chainIds[i], wTime, supply, userData);
-            if (user != address(0)) {
-                emit BroadcastUserPosition(user, chainIds);
-            }
         }
 
+        if (user != address(0)) {
+            emit BroadcastUserPosition(user, chainIds);
+        }
         emit BroadcastTotalSupply(supply, chainIds);
     }
 
-    function _afterAddSidechainContract(address, uint256 chainId) internal virtual override {
-        (VeBalance memory supply, uint256 wTime) = _applySlopeChange();
+    function _afterAddDestinationContract(address, uint256 chainId) internal virtual override {
+        (VeBalance memory supply, uint128 wTime) = _applySlopeChange();
         _broadcast(chainId, wTime, supply, EMPTY_BYTES);
     }
 
     function _broadcast(
         uint256 chainId,
-        uint256 wTime,
+        uint128 wTime,
         VeBalance memory supply,
         bytes memory userData
     ) internal {

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

@@ -19,7 +19,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
 
     constructor(address _governanceManager) CelerReceiverUpg(_governanceManager) {}
 
-    function totalSupplyCurrent() external view virtual override returns (uint128) {
+    function totalSupplyCurrent() public view virtual override returns (uint128) {
         return totalSupplyStored();
     }
 
@@ -65,9 +65,7 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, CelerReceiverUpg
 
     function balanceOf(address user) public view virtual override returns (uint128) {
         address delegator = delegatorOf[user];
-        if (delegatorOf[user] == address(0)) {
-            return super.balanceOf(user);
-        }
+        if (delegator == address(0)) return super.balanceOf(user);
         return super.balanceOf(delegator);
     }
 }

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

@@ -43,9 +43,13 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
         return _totalSupply.getCurrentValue();
     }
 
-    function totalSupplyCurrent() external virtual returns (uint128);
+    function totalSupplyCurrent() public virtual returns (uint128);
 
     function _isPositionExpired(address user) internal view returns (bool) {
         return MiniHelpers.isCurrentlyExpired(positionData[user].expiry);
     }
+
+    function totalSupplyAndBlanaceCurrent(address user) external returns (uint128, uint128) {
+        return (balanceOf(user), totalSupplyCurrent());
+    }
 }

package/contracts/core/Market/PendleMarket.sol

@@ -13,7 +13,6 @@ import "../../libraries/math/Math.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
 
 import "../LiquidityMining/PendleGauge.sol";
-import "../PendleERC20Permit.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
 /**
@@ -27,7 +26,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
     using Math for int256;
     using MarketMathCore for MarketState;
     using SafeERC20 for IERC20;
-    using SCYIndexLib for ISuperComposableYield;
+    using PYIndexLib for IPYieldToken;
 
     struct MarketStorage {
         int128 totalPt;
@@ -90,7 +89,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         returns (uint256 lpToAccount)
     {
         MarketState memory market = readState(true);
-        SCYIndex index = SCY.newIndex();
+        PYIndex index = YT.newIndex();
 
         uint256 scyDesired = IERC20(SCY).balanceOf(address(this)) - market.totalScy.Uint();
         uint256 ptDesired = IERC20(PT).balanceOf(address(this)) - market.totalPt.Uint();
@@ -161,7 +160,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         MarketState memory market = readState(true);
 
         (netScyOut, netScyToReserve) = market.swapExactPtForScy(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactPtIn,
             block.timestamp
         );
@@ -198,7 +197,7 @@ contract PendleMarket is PendleERC20, PendleGauge, IPMarket {
         MarketState memory market = readState(true);
 
         (netScyIn, netScyToReserve) = market.swapScyForExactPt(
-            SCY.newIndex(),
+            YT.newIndex(),
             exactPtOut,
             block.timestamp
         );

package/contracts/core/Market/PendleMarketFactory.sol

@@ -78,13 +78,14 @@ contract PendleMarketFactory is PermissionsV2Upg, Initializable, IPMarketFactory
         int256 scalarRoot,
         int256 initialAnchor
     ) external returns (address market) {
+        require(!IPPrincipalToken(PT).isExpired(), "PT is expired");
         require(IPYieldContractFactory(yieldContractFactory).isPT(PT), "Invalid PT");
         require(markets[PT][scalarRoot][initialAnchor] == address(0), "market already created");
 
         // no need salt since market's existence has been checked before hand
         market = SSTORE2Deployer.create2(
             marketCreationCodePointer,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController)
         );
 

package/contracts/core/PendleERC20.sol

@@ -352,7 +352,7 @@ contract PendleERC20 is Context, IERC20, IERC20Metadata {
     ) internal virtual {}
 
     function toUint248(uint256 x) internal virtual returns (uint248) {
-        require(x < (1 << 248)); // signed, lim = bit-1
+        require(x <= type(uint248).max); // signed, lim = bit-1
         return uint248(x);
     }
 }

package/contracts/core/YieldContracts/InterestManagerYT.sol

@@ -12,8 +12,6 @@ import "../../interfaces/IPYieldContractFactory.sol";
 import "../../libraries/SCY/SCYUtils.sol";
 import "../../libraries/helpers/TokenHelper.sol";
 
-import "../PendleERC20Permit.sol";
-
 /*
 With YT yielding more SCYs overtime, which is allowed to be redeemed by users, the reward distribution should
 be based on the amount of SCYs that their YT currently represent, plus with their dueInterest.

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -4,11 +4,11 @@ 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, Initializable, IPPrincipalToken {
+contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SCY;
     address public immutable factory;
     uint256 public immutable expiry;
@@ -30,7 +30,7 @@ contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalTo
         string memory _symbol,
         uint8 __decimals,
         uint256 _expiry
-    ) PendleERC20Permit(_name, _symbol, __decimals) {
+    ) PendleERC20(_name, _symbol, __decimals) {
         SCY = _SCY;
         expiry = _expiry;
         factory = msg.sender;

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -98,7 +98,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
         // no need salt since PT (and also YT) existence has been checked before hand
         PT = SSTORE2Deployer.create2(
             type(PendlePrincipalToken).creationCode,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(
                 SCY,
                 PT_PREFIX.concat(_SCY.name(), expiry, " "),
@@ -110,7 +110,7 @@ contract PendleYieldContractFactory is PermissionsV2Upg, Initializable, IPYieldC
 
         YT = SSTORE2Deployer.create2(
             pendleYtCreationCodePointer,
-            bytes32(0),
+            bytes32(block.chainid),
             abi.encode(
                 SCY,
                 PT,