@pendle/core-v2 6.3.0-fee-setter → 6.3.0-sweedtest

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./PendleGaugeControllerBaseUpg.sol";
 import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
+import "./PendleGaugeControllerBaseUpg.sol";
 
 // solhint-disable no-empty-blocks
 
@@ -17,12 +17,7 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
         address _PendleMsgReceiveEndpointUpg
     )
         PendleGaugeControllerBaseUpg(
-            _pendle,
-            _marketFactory,
-            _marketFactory2,
-            _marketFactory3,
-            _marketFactory4,
-            _marketFactory5
+            _pendle, _marketFactory, _marketFactory2, _marketFactory3, _marketFactory4, _marketFactory5
         )
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
     {
@@ -34,10 +29,8 @@ contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, Pend
     }
 
     function _executeMessage(bytes memory message) internal virtual override {
-        (uint128 wTime, address[] memory markets, uint256[] memory pendleAmounts) = abi.decode(
-            message,
-            (uint128, address[], uint256[])
-        );
+        (uint128 wTime, address[] memory markets, uint256[] memory pendleAmounts) =
+            abi.decode(message, (uint128, address[], uint256[]));
         _receiveVotingResults(wTime, markets, pendleAmounts);
     }
 }

package/contracts/LiquidityMining/PendleMerkleDistributor.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
 import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IPMerkleDistributor.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 
 contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, BoringOwnableUpgradeableV2, TokenHelper {
     address public immutable token;
@@ -26,11 +26,10 @@ contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, Boring
         __BoringOwnableV2_init(_owner);
     }
 
-    function claim(
-        address receiver,
-        uint256 totalAccrued,
-        bytes32[] calldata proof
-    ) external returns (uint256 amountOut) {
+    function claim(address receiver, uint256 totalAccrued, bytes32[] calldata proof)
+        external
+        returns (uint256 amountOut)
+    {
         address user = msg.sender;
         if (!_verifyMerkleData(user, totalAccrued, proof)) revert InvalidMerkleProof();
 
@@ -57,11 +56,10 @@ contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, Boring
         emit Claimed(user, receiver, amountOut);
     }
 
-    function verify(
-        address user,
-        uint256 totalAccrued,
-        bytes32[] calldata proof
-    ) external returns (uint256 amountClaimable) {
+    function verify(address user, uint256 totalAccrued, bytes32[] calldata proof)
+        external
+        returns (uint256 amountClaimable)
+    {
         if (!_verifyMerkleData(user, totalAccrued, proof)) revert InvalidMerkleProof();
         amountClaimable = totalAccrued - claimed[user];
         verified[user] = totalAccrued;

package/contracts/LiquidityMining/PendleMultiTokenMerkleDistributor.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 import "../core/libraries/BoringOwnableUpgradeableV2.sol";
-import "../core/libraries/TokenHelper.sol";
 import "../core/libraries/Errors.sol";
+import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IPMultiTokenMerkleDistributor.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
 
 contract PendleMultiTokenMerkleDistributor is
     IPMultiTokenMerkleDistributor,
@@ -31,12 +31,10 @@ contract PendleMultiTokenMerkleDistributor is
         __BoringOwnableV2_init(_owner);
     }
 
-    function claim(
-        address receiver,
-        address[] memory tokens,
-        uint256[] memory totalAccrueds,
-        bytes32[][] memory proofs
-    ) external returns (uint256[] memory amountOuts) {
+    function claim(address receiver, address[] memory tokens, uint256[] memory totalAccrueds, bytes32[][] memory proofs)
+        external
+        returns (uint256[] memory amountOuts)
+    {
         if (tokens.length != totalAccrueds.length || tokens.length != proofs.length) {
             revert Errors.ArrayLengthMismatch();
         }
@@ -76,12 +74,10 @@ contract PendleMultiTokenMerkleDistributor is
         }
     }
 
-    function verify(
-        address user,
-        address[] memory tokens,
-        uint256[] memory totalAccrueds,
-        bytes32[][] memory proofs
-    ) external returns (uint256[] memory amountClaimable) {
+    function verify(address user, address[] memory tokens, uint256[] memory totalAccrueds, bytes32[][] memory proofs)
+        external
+        returns (uint256[] memory amountClaimable)
+    {
         uint256 nToken = tokens.length;
         amountClaimable = new uint256[](nToken);
 
@@ -94,12 +90,11 @@ contract PendleMultiTokenMerkleDistributor is
         }
     }
 
-    function _verifyMerkleData(
-        address token,
-        address user,
-        uint256 amount,
-        bytes32[] memory proof
-    ) internal view returns (bool) {
+    function _verifyMerkleData(address token, address user, uint256 amount, bytes32[] memory proof)
+        internal
+        view
+        returns (bool)
+    {
         bytes32 leaf = keccak256(abi.encodePacked(token, user, amount));
         return MerkleProof.verify(proof, merkleRoot, leaf);
     }

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.17;
 
-import "./VotingControllerStorageUpg.sol";
-import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
-import "../libraries/VeBalanceLib.sol";
 import "../../core/libraries/math/PMath.sol";
 import "../../interfaces/IPGaugeControllerMainchain.sol";
 import "../../interfaces/IPVotingController.sol";
+import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
+import "../libraries/VeBalanceLib.sol";
+import "./VotingControllerStorageUpg.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 
 /*
@@ -39,18 +39,14 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
     using EnumerableMap for EnumerableMap.UintToAddressMap;
     using EnumerableSet for EnumerableSet.AddressSet;
 
-    constructor(
-        address _vePendle,
-        address _pendleMsgSendEndpoint,
-        uint256 initialApproxDestinationGas
-    )
+    constructor(address _vePendle, address _pendleMsgSendEndpoint, uint256 initialApproxDestinationGas)
         VotingControllerStorageUpg(_vePendle)
-        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) // constructor only set immutable variables
+        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) // constructor only set immutable
+        // variables
         initializer
-    //solhint-disable-next-line
-    {
+        //solhint-disable-next-line
 
-    }
+    {}
 
     function initialize(address _owner) external initializer {
         __BoringOwnableV2_init(_owner);
@@ -88,8 +84,9 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
         }
 
         uint256 totalVotedWeight = userData[user].totalVotedWeight;
-        if (totalVotedWeight > VeBalanceLib.USER_VOTE_MAX_WEIGHT)
+        if (totalVotedWeight > VeBalanceLib.USER_VOTE_MAX_WEIGHT) {
             revert Errors.VCExceededMaxWeight(totalVotedWeight, VeBalanceLib.USER_VOTE_MAX_WEIGHT);
+        }
     }
 
     /**
@@ -220,11 +217,12 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
      * @notice use the gov-privilege to force broadcast a message in case there are issues with LayerZero
      * @custom:gov NOTE TO GOV: gov should always call finalizeEpoch beforehand
      */
-    function forceBroadcastResults(
-        uint64 chainId,
-        uint128 wTime,
-        uint128 forcedPendlePerSec
-    ) external payable onlyOwner refundUnusedEth {
+    function forceBroadcastResults(uint64 chainId, uint128 wTime, uint128 forcedPendlePerSec)
+        external
+        payable
+        onlyOwner
+        refundUnusedEth
+    {
         _broadcastResults(chainId, wTime, forcedPendlePerSec, globalCap);
     }
 
@@ -256,12 +254,9 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
     //////////////////////////////////////////////////////////////*/
 
     /// @notice broadcast voting results of the timestamp to chainId
-    function _broadcastResults(
-        uint64 chainId,
-        uint128 wTime,
-        uint128 totalPendlePerSec,
-        uint256 currentGlobalCap
-    ) internal {
+    function _broadcastResults(uint64 chainId, uint128 wTime, uint128 totalPendlePerSec, uint256 currentGlobalCap)
+        internal
+    {
         uint256 totalVotes = weekData[wTime].totalVotes;
         if (totalVotes == 0) return;
 
@@ -289,10 +284,8 @@ contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerSto
 
     function _getUserVePendlePosition(address user) internal view returns (LockedPosition memory userPosition) {
         if (user == owner) {
-            (userPosition.amount, userPosition.expiry) = (
-                GOVERNANCE_PENDLE_VOTE,
-                WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME)
-            );
+            (userPosition.amount, userPosition.expiry) =
+            (GOVERNANCE_PENDLE_VOTE, WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME));
         } else {
             (userPosition.amount, userPosition.expiry) = vePendle.positionData(user);
         }

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.sol

@@ -5,11 +5,11 @@ import "../../interfaces/IPVeToken.sol";
 import "../../interfaces/IPVotingController.sol";
 
 import "../libraries/VeBalanceLib.sol";
-import "../libraries/WeekMath.sol";
 import "../libraries/VeHistoryLib.sol";
+import "../libraries/WeekMath.sol";
 
-import "../../core/libraries/MiniHelpers.sol";
 import "../../core/libraries/Errors.sol";
+import "../../core/libraries/MiniHelpers.sol";
 
 import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
 
@@ -110,10 +110,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         return __dep_userPoolHistory[user][pool].get(index);
     }
 
-    function getPoolData(
-        address pool,
-        uint128[] calldata wTimes
-    )
+    function getPoolData(address pool, uint128[] calldata wTimes)
         public
         view
         returns (
@@ -133,22 +130,26 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         }
     }
 
-    function getUserData(
-        address user,
-        address[] calldata pools
-    ) public view returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools) {
+    function getUserData(address user, address[] calldata pools)
+        public
+        view
+        returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools)
+    {
         UserData storage data = userData[user];
 
         totalVotedWeight = data.totalVotedWeight;
 
         voteForPools = new UserPoolData[](pools.length);
-        for (uint256 i = 0; i < pools.length; ++i) voteForPools[i] = data.voteForPools[pools[i]];
+        for (uint256 i = 0; i < pools.length; ++i) {
+            voteForPools[i] = data.voteForPools[pools[i]];
+        }
     }
 
-    function getWeekData(
-        uint128 wTime,
-        address[] calldata pools
-    ) public view returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes) {
+    function getWeekData(uint128 wTime, address[] calldata pools)
+        public
+        view
+        returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes)
+    {
         if (!wTime.isValidWTime()) revert Errors.InvalidWTime(wTime);
 
         WeekData storage data = weekData[wTime];
@@ -156,23 +157,28 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         (isEpochFinalized, totalVotes) = (data.isEpochFinalized, data.totalVotes);
 
         poolVotes = new uint128[](pools.length);
-        for (uint256 i = 0; i < pools.length; ++i) poolVotes[i] = data.poolVotes[pools[i]];
+        for (uint256 i = 0; i < pools.length; ++i) {
+            poolVotes[i] = data.poolVotes[pools[i]];
+        }
     }
 
     function getAllActivePools() external view returns (address[] memory) {
         return allActivePools.values();
     }
 
-    function getAllRemovedPools(
-        uint256 start,
-        uint256 end
-    ) external view returns (uint256 lengthOfRemovedPools, address[] memory arr) {
+    function getAllRemovedPools(uint256 start, uint256 end)
+        external
+        view
+        returns (uint256 lengthOfRemovedPools, address[] memory arr)
+    {
         lengthOfRemovedPools = allRemovedPools.length();
 
         if (end >= lengthOfRemovedPools) revert Errors.ArrayOutOfBounds();
 
         arr = new address[](end - start + 1);
-        for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
+        for (uint256 i = start; i <= end; ++i) {
+            arr[i - start] = allRemovedPools.at(i);
+        }
     }
 
     function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
@@ -219,12 +225,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
      * @notice modifies `user`'s vote weight on `pool`
      * @dev works by simply removing the old vote position, then adds in a fresh vote
      */
-    function _modifyVoteWeight(
-        address user,
-        address pool,
-        LockedPosition memory userPosition,
-        uint64 weight
-    ) internal returns (VeBalance memory newVote) {
+    function _modifyVoteWeight(address user, address pool, LockedPosition memory userPosition, uint64 weight)
+        internal
+        returns (VeBalance memory newVote)
+    {
         UserData storage uData = userData[user];
         PoolData storage pData = poolData[pool];
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -7,11 +7,11 @@ import "../../interfaces/IPVotingEscrowMainchain.sol";
 
 import "../libraries/VeHistoryLib.sol";
 
-import "../../core/libraries/MiniHelpers.sol";
 import "../../core/libraries/Errors.sol";
+import "../../core/libraries/MiniHelpers.sol";
 
-import "./VotingEscrowTokenBase.sol";
 import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
+import "./VotingEscrowTokenBase.sol";
 
 contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMainchain, PendleMsgSenderAppUpg {
     using SafeERC20 for IERC20;
@@ -40,11 +40,10 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
     // to ask for their vePendle balance at any wTime
     mapping(address => Checkpoints.History) internal userHistory;
 
-    constructor(
-        IERC20 _pendle,
-        address _pendleMsgSendEndpoint,
-        uint256 initialApproxDestinationGas
-    ) initializer PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) {
+    constructor(IERC20 _pendle, address _pendleMsgSendEndpoint, uint256 initialApproxDestinationGas)
+        initializer
+        PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas)
+    {
         pendle = _pendle;
         lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
         __BoringOwnableV2_init(msg.sender);
@@ -70,10 +69,10 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
      * @dev See `_increasePosition()` for details on inner workings.
      * @dev Sidechain broadcasting is not bundled since it can be done anytime after.
      */
-    function increaseLockPosition(
-        uint128 additionalAmountToLock,
-        uint128 newExpiry
-    ) public returns (uint128 newVeBalance) {
+    function increaseLockPosition(uint128 additionalAmountToLock, uint128 newExpiry)
+        public
+        returns (uint128 newVeBalance)
+    {
         address user = msg.sender;
 
         if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
@@ -123,7 +122,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
      * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
      */
     function totalSupplyCurrent() public virtual override(IPVeToken, VotingEscrowTokenBase) returns (uint128) {
-        (VeBalance memory supply, ) = _applySlopeChange();
+        (VeBalance memory supply,) = _applySlopeChange();
         return supply.getCurrentValue();
     }
 
@@ -166,14 +165,13 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
      * @dev works by simply removing the old position from all relevant data (as if the user has
      * never locked) and then add in the new position
      */
-    function _increasePosition(
-        address user,
-        uint128 amountToIncrease,
-        uint128 durationToIncrease
-    ) internal returns (uint128) {
+    function _increasePosition(address user, uint128 amountToIncrease, uint128 durationToIncrease)
+        internal
+        returns (uint128)
+    {
         LockedPosition memory oldPosition = positionData[user];
 
-        (VeBalance memory newSupply, ) = _applySlopeChange();
+        (VeBalance memory newSupply,) = _applySlopeChange();
 
         if (!MiniHelpers.isCurrentlyExpired(oldPosition.expiry)) {
             // remove old position not yet expired
@@ -182,10 +180,8 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
             slopeChanges[oldPosition.expiry] -= oldBalance.slope;
         }
 
-        LockedPosition memory newPosition = LockedPosition(
-            oldPosition.amount + amountToIncrease,
-            oldPosition.expiry + durationToIncrease
-        );
+        LockedPosition memory newPosition =
+            LockedPosition(oldPosition.amount + amountToIncrease, oldPosition.expiry + durationToIncrease);
 
         VeBalance memory newBalance = newPosition.convertToVeBalance();
         // add new position
@@ -227,7 +223,7 @@ contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMai
     function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
         if (chainIds.length == 0) revert Errors.ArrayEmpty();
 
-        (VeBalance memory supply, ) = _applySlopeChange();
+        (VeBalance memory supply,) = _applySlopeChange();
 
         bytes memory userData = (user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user]));
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -5,8 +5,8 @@ pragma solidity ^0.8.17;
 import "../libraries/VeBalanceLib.sol";
 import "../libraries/WeekMath.sol";
 
-import "./VotingEscrowTokenBase.sol";
 import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
+import "./VotingEscrowTokenBase.sol";
 
 // solhint-disable no-empty-blocks
 contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiverAppUpg, BoringOwnableUpgradeableV2 {
@@ -20,9 +20,10 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiver
 
     event SetNewUserPosition(LockedPosition position);
 
-    constructor(
-        address _PendleMsgReceiveEndpointUpg
-    ) initializer PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg) {
+    constructor(address _PendleMsgReceiveEndpointUpg)
+        initializer
+        PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
+    {
         __BoringOwnableV2_init(msg.sender);
     }
 
@@ -44,10 +45,8 @@ contract VotingEscrowPendleSidechain is VotingEscrowTokenBase, PendleMsgReceiver
      * @dev If the message also contains some users' position, we should update it
      */
     function _executeMessage(bytes memory message) internal virtual override {
-        (uint128 msgTime, VeBalance memory supply, bytes memory userData) = abi.decode(
-            message,
-            (uint128, VeBalance, bytes)
-        );
+        (uint128 msgTime, VeBalance memory supply, bytes memory userData) =
+            abi.decode(message, (uint128, VeBalance, bytes));
         _setNewTotalSupply(msgTime, supply);
         if (userData.length > 0) {
             _setNewUserPosition(userData);

package/contracts/LiquidityMining/libraries/VeBalanceLib.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.0;
 
-import "../../core/libraries/math/PMath.sol";
 import "../../core/libraries/Errors.sol";
+import "../../core/libraries/math/PMath.sol";
 
 struct VeBalance {
     uint128 bias;
@@ -60,10 +60,11 @@ library VeBalanceLib {
         res.bias = res.slope * position.expiry;
     }
 
-    function convertToVeBalance(
-        LockedPosition memory position,
-        uint256 weight
-    ) internal pure returns (VeBalance memory res) {
+    function convertToVeBalance(LockedPosition memory position, uint256 weight)
+        internal
+        pure
+        returns (VeBalance memory res)
+    {
         res.slope = ((position.amount * weight) / MAX_LOCK_TIME / USER_VOTE_MAX_WEIGHT).Uint128();
         res.bias = res.slope * position.expiry;
     }