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

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,

package/contracts/LiquidityMining/VotingController/VotingControllerStorageUpg.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/IPVeToken.sol";
 import "../../interfaces/IPVotingController.sol";
@@ -93,15 +93,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
     }
 
     /// @notice deprecated, only kept for compatibility reasons
-    function getUserPoolHistoryAt(
-        address user,
-        address pool,
-        uint256 index
-    ) external view returns (Checkpoint memory) {
+    function getUserPoolHistoryAt(address user, address pool, uint256 index) external view returns (Checkpoint memory) {
         return __dep_userPoolHistory[user][pool].get(index);
     }
 
-
     function getPoolData(
         address pool,
         uint128[] calldata wTimes
@@ -116,11 +111,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         )
     {
         PoolData storage data = poolData[pool];
-        (chainId, lastSlopeChangeAppliedAt, totalVote) = (
-            data.chainId,
-            data.lastSlopeChangeAppliedAt,
-            data.totalVote
-        );
+        (chainId, lastSlopeChangeAppliedAt, totalVote) = (data.chainId, data.lastSlopeChangeAppliedAt, data.totalVote);
 
         slopeChanges = new uint128[](wTimes.length);
         for (uint256 i = 0; i < wTimes.length; ++i) {
@@ -175,10 +166,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         return activeChainPools[chainId].values();
     }
 
-    function getUserPoolVote(
-        address user,
-        address pool
-    ) external view returns (UserPoolData memory) {
+    function getUserPoolVote(address user, address pool) external view returns (UserPoolData memory) {
         return userData[user].voteForPools[pool];
     }
 

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.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/utils/structs/EnumerableSet.sol";
 
@@ -13,11 +13,7 @@ import "../../core/libraries/Errors.sol";
 import "./VotingEscrowTokenBase.sol";
 import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
 
-contract VotingEscrowPendleMainchain is
-    VotingEscrowTokenBase,
-    IPVotingEscrowMainchain,
-    PendleMsgSenderAppUpg
-{
+contract VotingEscrowPendleMainchain is VotingEscrowTokenBase, IPVotingEscrowMainchain, PendleMsgSenderAppUpg {
     using SafeERC20 for IERC20;
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
@@ -25,8 +21,7 @@ contract VotingEscrowPendleMainchain is
     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_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)));
 
@@ -127,12 +122,7 @@ contract VotingEscrowPendleMainchain is
      * @notice update & return the current totalSupply, but does not broadcast info to other chains
      * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
      */
-    function totalSupplyCurrent()
-        public
-        virtual
-        override(IPVeToken, VotingEscrowTokenBase)
-        returns (uint128)
-    {
+    function totalSupplyCurrent() public virtual override(IPVeToken, VotingEscrowTokenBase) returns (uint128) {
         (VeBalance memory supply, ) = _applySlopeChange();
         return supply.getCurrentValue();
     }
@@ -146,10 +136,7 @@ contract VotingEscrowPendleMainchain is
      * @notice updates and broadcast the position of `user` to different chains, also updates and
      * broadcasts totalSupply
      */
-    function broadcastUserPosition(
-        address user,
-        uint256[] calldata chainIds
-    ) public payable refundUnusedEth {
+    function broadcastUserPosition(address user, uint256[] calldata chainIds) public payable refundUnusedEth {
         if (user == address(0)) revert Errors.ZeroAddress();
         _broadcastPosition(user, chainIds);
     }
@@ -158,24 +145,17 @@ contract VotingEscrowPendleMainchain is
         return userHistory[user].length();
     }
 
-    function getUserHistoryAt(
-        address user,
-        uint256 index
-    ) external view returns (Checkpoint memory) {
+    function getUserHistoryAt(address user, uint256 index) external view returns (Checkpoint memory) {
         return userHistory[user].get(index);
     }
 
-    function getBroadcastSupplyFee(
-        uint256[] calldata chainIds
-    ) external view returns (uint256 fee) {
+    function getBroadcastSupplyFee(uint256[] calldata chainIds) external view returns (uint256 fee) {
         for (uint256 i = 0; i < chainIds.length; i++) {
             fee += _getSendMessageFee(chainIds[i], SAMPLE_SUPPLY_UPDATE_MESSAGE);
         }
     }
 
-    function getBroadcastPositionFee(
-        uint256[] calldata chainIds
-    ) external view returns (uint256 fee) {
+    function getBroadcastPositionFee(uint256[] calldata chainIds) external view returns (uint256 fee) {
         for (uint256 i = 0; i < chainIds.length; i++) {
             fee += _getSendMessageFee(chainIds[i], SAMPLE_POSITION_UPDATE_MESSAGE);
         }
@@ -249,13 +229,10 @@ contract VotingEscrowPendleMainchain is
 
         (VeBalance memory supply, ) = _applySlopeChange();
 
-        bytes memory userData = (
-            user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
-        );
+        bytes memory userData = (user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user]));
 
         for (uint256 i = 0; i < chainIds.length; ++i) {
-            if (!destinationContracts.contains(chainIds[i]))
-                revert Errors.ChainNotSupported(chainIds[i]);
+            if (!destinationContracts.contains(chainIds[i])) revert Errors.ChainNotSupported(chainIds[i]);
             _broadcast(chainIds[i], uint128(block.timestamp), supply, userData);
         }
 
@@ -265,12 +242,7 @@ contract VotingEscrowPendleMainchain is
         emit BroadcastTotalSupply(supply, chainIds);
     }
 
-    function _broadcast(
-        uint256 chainId,
-        uint128 msgTime,
-        VeBalance memory supply,
-        bytes memory userData
-    ) internal {
+    function _broadcast(uint256 chainId, uint128 msgTime, VeBalance memory supply, bytes memory userData) internal {
         _sendMessage(chainId, abi.encode(msgTime, supply, userData));
     }
 }