@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-12

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiveEndpointUpg.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/ILayerZeroEndpoint.sol";
 import "../../interfaces/IPMsgReceiverApp.sol";
@@ -15,25 +15,14 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
  * So we can leave the configuration unset.
  */
 
-contract PendleMsgReceiveEndpointUpg is
-    ILayerZeroReceiver,
-    Initializable,
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable
-{
+contract PendleMsgReceiveEndpointUpg is ILayerZeroReceiver, Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
     using ExcessivelySafeCall for address;
 
     address public immutable lzEndpoint;
     address public immutable sendEndpointAddr;
     uint64 public immutable sendEndpointChainId;
 
-    event MessageFailed(
-        uint16 _srcChainId,
-        bytes _path,
-        uint64 _nonce,
-        bytes _payload,
-        bytes _reason
-    );
+    event MessageFailed(uint16 _srcChainId, bytes _path, uint64 _nonce, bytes _payload, bytes _reason);
 
     modifier onlyLzEndpoint() {
         if (msg.sender != address(lzEndpoint)) revert Errors.OnlyLayerZeroEndpoint();
@@ -55,11 +44,7 @@ contract PendleMsgReceiveEndpointUpg is
 
     // by default we will use LZ's default version (most updated version). Hence, it's not necessary
     // to call setLzReceiveVersion
-    constructor(
-        address _lzEndpoint,
-        address _sendEndpointAddr,
-        uint64 _sendEndpointChainId
-    ) initializer {
+    constructor(address _lzEndpoint, address _sendEndpointAddr, uint64 _sendEndpointChainId) initializer {
         lzEndpoint = _lzEndpoint;
         sendEndpointAddr = _sendEndpointAddr;
         sendEndpointChainId = _sendEndpointChainId;
@@ -88,10 +73,7 @@ contract PendleMsgReceiveEndpointUpg is
         }
     }
 
-    function govExecuteMessage(
-        address receiver,
-        bytes calldata message
-    ) external payable onlyOwner {
+    function govExecuteMessage(address receiver, bytes calldata message) external payable onlyOwner {
         IPMsgReceiverApp(receiver).executeMessage(message);
     }
 

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgReceiverAppUpg.sol

@@ -13,8 +13,7 @@ abstract contract PendleMsgReceiverAppUpg is IPMsgReceiverApp {
     uint256[100] private __gap;
 
     modifier onlyFromPendleMsgReceiveEndpoint() {
-        if (msg.sender != pendleMsgReceiveEndpoint)
-            revert Errors.MsgNotFromReceiveEndpoint(msg.sender);
+        if (msg.sender != pendleMsgReceiveEndpoint) revert Errors.MsgNotFromReceiveEndpoint(msg.sender);
         _;
     }
 
@@ -22,9 +21,7 @@ abstract contract PendleMsgReceiverAppUpg is IPMsgReceiverApp {
         pendleMsgReceiveEndpoint = _pendleMsgReceiveEndpoint;
     }
 
-    function executeMessage(
-        bytes calldata message
-    ) external virtual onlyFromPendleMsgReceiveEndpoint {
+    function executeMessage(bytes calldata message) external virtual onlyFromPendleMsgReceiveEndpoint {
         _executeMessage(message);
     }
 

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSendEndpointUpg.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../interfaces/IPMsgSendEndpoint.sol";
 import "../../interfaces/ILayerZeroEndpoint.sol";
@@ -14,12 +14,7 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
  * So we can leave the configuration unset.
  */
 
-contract PendleMsgSendEndpointUpg is
-    IPMsgSendEndpoint,
-    Initializable,
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable
-{
+contract PendleMsgSendEndpointUpg is IPMsgSendEndpoint, Initializable, UUPSUpgradeable, BoringOwnableUpgradeable {
     using EnumerableMap for EnumerableMap.UintToAddressMap;
 
     address payable public immutable refundAddress;
@@ -64,7 +59,7 @@ contract PendleMsgSendEndpointUpg is
         uint256 estimatedGasAmount
     ) external payable onlyWhitelisted {
         bytes memory path = abi.encodePacked(receiveEndpoints.get(dstChainId), address(this));
-        lzEndpoint.send{ value: msg.value }(
+        lzEndpoint.send{value: msg.value}(
             LayerZeroHelper._getLayerZeroChainIds(dstChainId),
             path,
             abi.encode(dstAddress, payload),
@@ -74,10 +69,7 @@ contract PendleMsgSendEndpointUpg is
         );
     }
 
-    function addReceiveEndpoints(
-        address endpointAddr,
-        uint256 endpointChainId
-    ) external payable onlyOwner {
+    function addReceiveEndpoints(address endpointAddr, uint256 endpointChainId) external payable onlyOwner {
         receiveEndpoints.set(endpointChainId, endpointAddr);
     }
 
@@ -89,11 +81,7 @@ contract PendleMsgSendEndpointUpg is
         ILayerZeroEndpoint(lzEndpoint).setSendVersion(_newVersion);
     }
 
-    function getAllReceiveEndpoints()
-        external
-        view
-        returns (uint256[] memory chainIds, address[] memory addrs)
-    {
+    function getAllReceiveEndpoints() external view returns (uint256[] memory chainIds, address[] memory addrs) {
         uint256 length = receiveEndpoints.length();
         chainIds = new uint256[](length);
         addrs = new address[](length);
@@ -105,9 +93,7 @@ contract PendleMsgSendEndpointUpg is
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    function _getAdapterParams(
-        uint256 estimatedGasAmount
-    ) internal pure returns (bytes memory adapterParams) {
+    function _getAdapterParams(uint256 estimatedGasAmount) internal pure returns (bytes memory adapterParams) {
         // this is more like "type" rather than version
         // It is the type of adapter params you want to pass to relayer
         adapterParams = abi.encodePacked(uint16(1), estimatedGasAmount);

package/contracts/LiquidityMining/CrossChainMsg/PendleMsgSenderAppUpg.sol

@@ -38,20 +38,11 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         uint256 estimatedGasAmount = approxDstExecutionGas;
         uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message, estimatedGasAmount);
         // LM contracts won't hold ETH on its own so this is fine
-        if (address(this).balance < fee)
-            revert Errors.InsufficientFeeToSendMsg(address(this).balance, fee);
-        pendleMsgSendEndpoint.sendMessage{ value: fee }(
-            toAddr,
-            chainId,
-            message,
-            estimatedGasAmount
-        );
+        if (address(this).balance < fee) revert Errors.InsufficientFeeToSendMsg(address(this).balance, fee);
+        pendleMsgSendEndpoint.sendMessage{value: fee}(toAddr, chainId, message, estimatedGasAmount);
     }
 
-    function addDestinationContract(
-        address _address,
-        uint256 _chainId
-    ) external payable onlyOwner {
+    function addDestinationContract(address _address, uint256 _chainId) external payable onlyOwner {
         destinationContracts.set(_chainId, _address);
     }
 
@@ -59,11 +50,7 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         approxDstExecutionGas = gas;
     }
 
-    function getAllDestinationContracts()
-        public
-        view
-        returns (uint256[] memory chainIds, address[] memory addrs)
-    {
+    function getAllDestinationContracts() public view returns (uint256[] memory chainIds, address[] memory addrs) {
         uint256 length = destinationContracts.length();
         chainIds = new uint256[](length);
         addrs = new address[](length);
@@ -73,16 +60,8 @@ abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
         }
     }
 
-    function _getSendMessageFee(
-        uint256 chainId,
-        bytes memory message
-    ) internal view returns (uint256) {
+    function _getSendMessageFee(uint256 chainId, bytes memory message) internal view returns (uint256) {
         return
-            pendleMsgSendEndpoint.calcFee(
-                destinationContracts.get(chainId),
-                chainId,
-                message,
-                approxDstExecutionGas
-            );
+            pendleMsgSendEndpoint.calcFee(destinationContracts.get(chainId), chainId, message, approxDstExecutionGas);
     }
 }

package/contracts/LiquidityMining/CrossChainMsg/libraries/ExcessivelySafeCall.sol

@@ -2,8 +2,7 @@
 pragma solidity >=0.7.6;
 
 library ExcessivelySafeCall {
-    uint256 constant LOW_28_MASK =
-        0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+    uint256 constant LOW_28_MASK = 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
 
     /// @notice Use when you _really_ really _really_ don't trust the called
     /// contract. This prevents the called contract from causing reversion of

package/contracts/LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol

@@ -47,4 +47,4 @@ library LayerZeroHelper {
             dst := mload(add(add(path, EVM_ADDRESS_SIZE), 0))
         }
     }
-}
+}

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -24,11 +24,7 @@ import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
  * on inheriting contracts
  */
 
-abstract contract PendleGaugeControllerBaseUpg is
-    IPGaugeController,
-    BoringOwnableUpgradeable,
-    UUPSUpgradeable
-{
+abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnableUpgradeable, UUPSUpgradeable {
     using SafeERC20 for IERC20;
     using PMath for uint256;
 
@@ -43,6 +39,7 @@ abstract contract PendleGaugeControllerBaseUpg is
 
     address public immutable pendle;
     IPMarketFactory public immutable marketFactory;
+    IPMarketFactory public immutable marketFactory2;
 
     mapping(address => MarketRewardData) public rewardData;
     mapping(uint128 => bool) public epochRewardReceived;
@@ -50,13 +47,20 @@ abstract contract PendleGaugeControllerBaseUpg is
     uint256[100] private __gap;
 
     modifier onlyPendleMarket() {
-        if (!marketFactory.isValidMarket(msg.sender)) revert Errors.GCNotPendleMarket(msg.sender);
-        _;
+        if (
+            marketFactory.isValidMarket(msg.sender) ||
+            (marketFactory2 != IPMarketFactory(address(0)) && marketFactory2.isValidMarket(msg.sender))
+        ) {
+            _;
+        } else {
+            revert Errors.GCNotPendleMarket(msg.sender);
+        }
     }
 
-    constructor(address _pendle, address _marketFactory) {
+    constructor(address _pendle, address _marketFactory, address _marketFactory2) {
         pendle = _pendle;
         marketFactory = IPMarketFactory(_marketFactory);
+        marketFactory2 = IPMarketFactory(_marketFactory2);
     }
 
     /**
@@ -88,19 +92,16 @@ abstract contract PendleGaugeControllerBaseUpg is
      * @notice receive voting results from VotingController. Only the first message for a timestamp
      * will be accepted, all subsequent messages will be ignored
      */
-    function _receiveVotingResults(
-        uint128 wTime,
-        address[] memory markets,
-        uint256[] memory pendleAmounts
-    ) internal {
+    function _receiveVotingResults(uint128 wTime, address[] memory markets, uint256[] memory pendleAmounts) internal {
         if (markets.length != pendleAmounts.length) revert Errors.ArrayLengthMismatch();
 
         if (epochRewardReceived[wTime]) return; // only accept the first message for the wTime
         epochRewardReceived[wTime] = true;
 
         for (uint256 i = 0; i < markets.length; ++i) {
-            if (!IPMarket(markets[i]).isExpired())
+            if (!IPMarket(markets[i]).isExpired()) {
                 _addRewardsToMarket(markets[i], pendleAmounts[i].Uint128());
+            }
         }
 
         emit ReceiveVotingResults(wTime, markets, pendleAmounts);
@@ -132,9 +133,7 @@ abstract contract PendleGaugeControllerBaseUpg is
      * Pendle distributed to the accumulatedPendle
      * @dev expect to update accumulatedPendle & lastUpdated in MarketRewardData
      */
-    function _getUpdatedMarketReward(
-        address market
-    ) internal view returns (MarketRewardData memory) {
+    function _getUpdatedMarketReward(address market) internal view returns (MarketRewardData memory) {
         MarketRewardData memory rwd = rewardData[market];
         uint128 newLastUpdated = uint128(PMath.min(uint128(block.timestamp), rwd.incentiveEndsAt));
         rwd.accumulatedPendle += rwd.pendlePerSec * (newLastUpdated - rwd.lastUpdated);

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerMainchainUpg.sol

@@ -1,13 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./PendleGaugeControllerBaseUpg.sol";
 import "../../interfaces/IPGaugeControllerMainchain.sol";
 
-contract PendleGaugeControllerMainchainUpg is
-    PendleGaugeControllerBaseUpg,
-    IPGaugeControllerMainchain
-{
+contract PendleGaugeControllerMainchainUpg is PendleGaugeControllerBaseUpg, IPGaugeControllerMainchain {
     address public immutable votingController;
 
     modifier onlyVotingController() {
@@ -18,9 +15,11 @@ contract PendleGaugeControllerMainchainUpg is
     constructor(
         address _votingController,
         address _pendle,
-        address _marketFactory
-    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory) initializer {
+        address _marketFactory,
+        address _marketFactory2
+    ) PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2) {
         votingController = _votingController;
+        _disableInitializers();
     }
 
     function initialize() external initializer {

package/contracts/LiquidityMining/GaugeController/PendleGaugeControllerSidechainUpg.sol

@@ -1,24 +1,23 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./PendleGaugeControllerBaseUpg.sol";
 import "../CrossChainMsg/PendleMsgReceiverAppUpg.sol";
 
 // solhint-disable no-empty-blocks
 
-contract PendleGaugeControllerSidechainUpg is
-    PendleGaugeControllerBaseUpg,
-    PendleMsgReceiverAppUpg
-{
+contract PendleGaugeControllerSidechainUpg is PendleGaugeControllerBaseUpg, PendleMsgReceiverAppUpg {
     constructor(
         address _pendle,
         address _marketFactory,
+        address _marketFactory2,
         address _PendleMsgReceiveEndpointUpg
     )
-        PendleGaugeControllerBaseUpg(_pendle, _marketFactory)
+        PendleGaugeControllerBaseUpg(_pendle, _marketFactory, _marketFactory2)
         PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
-        initializer
-    {}
+    {
+        _disableInitializers();
+    }
 
     function initialize() external initializer {
         __BoringOwnable_init();

package/contracts/LiquidityMining/PendleMerkleDistributor.sol

@@ -8,12 +8,7 @@ import "../core/libraries/BoringOwnableUpgradeable.sol";
 import "../core/libraries/TokenHelper.sol";
 import "../interfaces/IPMerkleDistributor.sol";
 
-contract PendleMerkleDistributor is
-    IPMerkleDistributor,
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable,
-    TokenHelper
-{
+contract PendleMerkleDistributor is IPMerkleDistributor, UUPSUpgradeable, BoringOwnableUpgradeable, TokenHelper {
     address public immutable token;
 
     bytes32 public merkleRoot;
@@ -74,11 +69,7 @@ contract PendleMerkleDistributor is
         emit Verified(user, amountClaimable);
     }
 
-    function _verifyMerkleData(
-        address user,
-        uint256 amount,
-        bytes32[] calldata proof
-    ) internal view returns (bool) {
+    function _verifyMerkleData(address user, uint256 amount, bytes32[] calldata proof) internal view returns (bool) {
         bytes32 leaf = keccak256(abi.encodePacked(user, amount));
         return MerkleProof.verify(proof, merkleRoot, leaf);
     }

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributor.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
@@ -37,19 +37,14 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         _;
     }
 
-    constructor(
-        address _votingController,
-        address _vePendle,
-        address _rewardToken
-    ) initializer {
+    constructor(address _votingController, address _vePendle, address _rewardToken) initializer {
         votingController = _votingController;
         vePendle = _vePendle;
         token = _rewardToken;
     }
 
     function addPool(address pool, uint256 _startWeek) external onlyOwner {
-        if (!WeekMath.isValidWTime(_startWeek) || _startWeek == 0)
-            revert Errors.FDInvalidStartEpoch(_startWeek);
+        if (!WeekMath.isValidWTime(_startWeek) || _startWeek == 0) revert Errors.FDInvalidStartEpoch(_startWeek);
 
         if (lastFundedWeek[pool] != 0) revert Errors.FDPoolAlreadyExists(pool);
 
@@ -70,8 +65,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         uint256 totalAmountToFund
     ) external onlyOwner {
         uint256 length = pools.length;
-        if (wTimes.length != length || amounts.length != length)
-            revert Errors.ArrayLengthMismatch();
+        if (wTimes.length != length || amounts.length != length) revert Errors.ArrayLengthMismatch();
 
         uint256 totalFunded = 0;
         for (uint256 i = 0; i < length; ++i) {
@@ -79,17 +73,12 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
             totalFunded += amounts[i].sum();
         }
 
-        if (totalFunded != totalAmountToFund)
-            revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
+        if (totalFunded != totalAmountToFund) revert Errors.FDTotalAmountFundedNotMatch(totalFunded, totalAmountToFund);
 
         IERC20(token).transferFrom(msg.sender, address(this), totalFunded);
     }
 
-    function _fund(
-        address pool,
-        uint256[] calldata wTimes,
-        uint256[] calldata amounts
-    ) internal ensureValidPool(pool) {
+    function _fund(address pool, uint256[] calldata wTimes, uint256[] calldata amounts) internal ensureValidPool(pool) {
         if (wTimes.length != amounts.length) revert Errors.FDEpochLengthMismatch();
 
         uint256 lastFunded = lastFundedWeek[pool];
@@ -100,8 +89,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
             uint256 wTime = wTimes[i];
             uint256 amount = amounts[i];
 
-            if (wTime != lastFunded + WeekMath.WEEK)
-                revert Errors.FDInvalidWTimeFund(lastFunded, wTime);
+            if (wTime != lastFunded + WeekMath.WEEK) revert Errors.FDInvalidWTimeFund(lastFunded, wTime);
 
             fees[pool][wTime] += amount;
             lastFunded += WeekMath.WEEK;
@@ -114,10 +102,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         lastFundedWeek[pool] = lastFunded;
     }
 
-    function claimReward(address user, address[] calldata pools)
-        external
-        returns (uint256[] memory amountRewardOut)
-    {
+    function claimReward(address user, address[] calldata pools) external returns (uint256[] memory amountRewardOut) {
         amountRewardOut = new uint256[](pools.length);
         for (uint256 i = 0; i < pools.length; ) {
             amountRewardOut[i] = _accumulateUserReward(pools[i], user);
@@ -132,11 +117,10 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         return allPools;
     }
 
-    function _accumulateUserReward(address pool, address user)
-        internal
-        ensureValidPool(pool)
-        returns (uint256 totalReward)
-    {
+    function _accumulateUserReward(
+        address pool,
+        address user
+    ) internal ensureValidPool(pool) returns (uint256 totalReward) {
         uint256 length = _getUserCheckpointLength(pool, user);
         if (length == 0) return 0;
 
@@ -180,10 +164,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
             curWeek += WeekMath.WEEK;
         }
 
-        userInfo[pool][user] = UserInfo({
-            firstUnclaimedWeek: uint128(curWeek),
-            iter: uint128(iter)
-        });
+        userInfo[pool][user] = UserInfo({firstUnclaimedWeek: uint128(curWeek), iter: uint128(iter)});
     }
 
     function _getPoolTotalSharesAt(address pool, uint128 wTime) internal view returns (uint256) {
@@ -194,11 +175,7 @@ contract PendleFeeDistributor is UUPSUpgradeable, BoringOwnableUpgradeable, IPFe
         }
     }
 
-    function _getUserCheckpointAt(
-        address pool,
-        address user,
-        uint256 index
-    ) internal view returns (Checkpoint memory) {
+    function _getUserCheckpointAt(address pool, address user, uint256 index) internal view returns (Checkpoint memory) {
         if (pool == vePendle) {
             return IPVotingEscrowMainchain(vePendle).getUserHistoryAt(user, index);
         } else {

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributorV2.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
@@ -9,12 +9,7 @@ import "../../core/libraries/TokenHelper.sol";
 import "../../core/libraries/Errors.sol";
 import "../../interfaces/IPFeeDistributorV2.sol";
 
-contract PendleFeeDistributorV2 is
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable,
-    IPFeeDistributorV2,
-    TokenHelper
-{
+contract PendleFeeDistributorV2 is UUPSUpgradeable, BoringOwnableUpgradeable, IPFeeDistributorV2, TokenHelper {
     bytes32 public merkleRoot;
 
     struct ProtocolData {
@@ -52,10 +47,10 @@ contract PendleFeeDistributorV2 is
         emit Claimed(user, amountOut);
     }
 
-    function claimProtocol(address receiver, address[] calldata pools)
-        external
-        returns (uint256 totalAmountOut, uint256[] memory amountsOut)
-    {
+    function claimProtocol(
+        address receiver,
+        address[] calldata pools
+    ) external returns (uint256 totalAmountOut, uint256[] memory amountsOut) {
         unchecked {
             address user = msg.sender;
 
@@ -81,11 +76,10 @@ contract PendleFeeDistributorV2 is
         }
     }
 
-    function getProtocolClaimables(address user, address[] calldata pools)
-        external
-        view
-        returns (uint256[] memory claimables)
-    {
+    function getProtocolClaimables(
+        address user,
+        address[] calldata pools
+    ) external view returns (uint256[] memory claimables) {
         unchecked {
             uint256 nPools = pools.length;
             claimables = new uint256[](nPools);
@@ -103,21 +97,13 @@ contract PendleFeeDistributorV2 is
         return protocol[user].totalAccrued;
     }
 
-    function _verifyMerkleData(
-        address user,
-        uint256 amount,
-        bytes32[] calldata proof
-    ) internal view returns (bool) {
+    function _verifyMerkleData(address user, uint256 amount, bytes32[] calldata proof) internal view returns (bool) {
         bytes32 leaf = keccak256(abi.encodePacked(user, amount));
         return MerkleProof.verify(proof, merkleRoot, leaf);
     }
 
     // ----------------- owner logic -----------------
-    function setMerkleRootAndFund(bytes32 newMerkleRoot, uint256 amountToFund)
-        external
-        payable
-        onlyOwner
-    {
+    function setMerkleRootAndFund(bytes32 newMerkleRoot, uint256 amountToFund) external payable onlyOwner {
         _transferIn(NATIVE, msg.sender, amountToFund);
         merkleRoot = newMerkleRoot;
         emit SetMerkleRootAndFund(newMerkleRoot, amountToFund);
@@ -134,12 +120,12 @@ contract PendleFeeDistributorV2 is
 
     function updateProtocolClaimable(UpdateProtocolStruct calldata ele) public onlyOwner {
         unchecked {
-            (
-                address user,
-                uint256[] calldata topUps,
-                address[] calldata pools,
-                bytes32[] calldata proof
-            ) = (ele.user, ele.topUps, ele.pools, ele.proof);
+            (address user, uint256[] calldata topUps, address[] calldata pools, bytes32[] calldata proof) = (
+                ele.user,
+                ele.topUps,
+                ele.pools,
+                ele.proof
+            );
 
             uint256 nPools = pools.length;
             if (nPools != topUps.length) revert Errors.ArrayLengthMismatch();
@@ -152,8 +138,7 @@ contract PendleFeeDistributorV2 is
             }
 
             uint256 newTotalAccrued = protocol[user].totalAccrued + sumTopUps;
-            if (!_verifyMerkleData(user, newTotalAccrued, proof))
-                revert Errors.InvalidMerkleProof();
+            if (!_verifyMerkleData(user, newTotalAccrued, proof)) revert Errors.InvalidMerkleProof();
 
             protocol[user].totalAccrued = newTotalAccrued;
             emit UpdateProtocolClaimable(user, sumTopUps);

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./VotingControllerStorageUpg.sol";
 import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
@@ -32,11 +32,7 @@ Cons:
     - Does not guarantee the reward will be distributed on epoch start and end
 */
 
-contract PendleVotingControllerUpg is
-    PendleMsgSenderAppUpg,
-    VotingControllerStorageUpg,
-    UUPSUpgradeable
-{
+contract PendleVotingControllerUpg is PendleMsgSenderAppUpg, VotingControllerStorageUpg, UUPSUpgradeable {
     using VeBalanceLib for VeBalance;
     using PMath for uint256;
     using PMath for int256;
@@ -243,11 +239,7 @@ contract PendleVotingControllerUpg is
 
         if (chainId == block.chainid) {
             address gaugeController = destinationContracts.get(chainId);
-            IPGaugeControllerMainchain(gaugeController).updateVotingResults(
-                wTime,
-                pools,
-                totalPendleAmounts
-            );
+            IPGaugeControllerMainchain(gaugeController).updateVotingResults(wTime, pools, totalPendleAmounts);
         } else {
             _sendMessage(chainId, abi.encode(wTime, pools, totalPendleAmounts));
         }
@@ -255,9 +247,7 @@ contract PendleVotingControllerUpg is
         emit BroadcastResults(chainId, wTime, totalPendlePerSec);
     }
 
-    function _getUserVePendlePosition(
-        address user
-    ) internal view returns (LockedPosition memory userPosition) {
+    function _getUserVePendlePosition(address user) internal view returns (LockedPosition memory userPosition) {
         if (user == owner) {
             (userPosition.amount, userPosition.expiry) = (
                 GOVERNANCE_PENDLE_VOTE,