@pendle/core-v2 1.2.1-testnet → 1.3.0-testnet

package/contracts/LiquidityMining/VeDistributor/PendleFeeDistributor.sol

@@ -37,11 +37,7 @@ 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;
@@ -114,10 +110,10 @@ 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 +128,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;
 

package/contracts/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -226,11 +226,7 @@ contract PendleVotingControllerUpg is
     //////////////////////////////////////////////////////////////*/
 
     /// @notice broadcast voting results of the timestamp to chainId
-    function _broadcastResults(
-        uint64 chainId,
-        uint128 wTime,
-        uint128 totalPendlePerSec
-    ) internal {
+    function _broadcastResults(uint64 chainId, uint128 wTime, uint128 totalPendlePerSec) internal {
         uint256 totalVotes = weekData[wTime].totalVotes;
         if (totalVotes == 0) return;
 
@@ -259,11 +255,9 @@ 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

@@ -46,7 +46,7 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
 
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
     uint128 public constant WEEK = 1 weeks;
-    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10 * (10**6) * (10**18); // 10 mils of PENDLE
+    uint128 public constant GOVERNANCE_PENDLE_VOTE = 10 * (10 ** 6) * (10 ** 18); // 10 mils of PENDLE
 
     IPVeToken public immutable vePendle;
 
@@ -87,7 +87,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         return weekData[wTime].poolVotes[pool];
     }
 
-    function getPoolData(address pool, uint128[] calldata wTimes)
+    function getPoolData(
+        address pool,
+        uint128[] calldata wTimes
+    )
         public
         view
         returns (
@@ -111,11 +114,10 @@ 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;
@@ -124,15 +126,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         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];
@@ -147,11 +144,10 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         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();
@@ -164,11 +160,10 @@ 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];
     }
 
@@ -205,20 +200,12 @@ abstract contract VotingControllerStorageUpg is IPVotingController {
         delete poolData[pool];
     }
 
-    function _setFinalPoolVoteForWeek(
-        address pool,
-        uint128 wTime,
-        uint128 vote
-    ) internal {
+    function _setFinalPoolVoteForWeek(address pool, uint128 wTime, uint128 vote) internal {
         weekData[wTime].totalVotes += vote;
         weekData[wTime].poolVotes[pool] = vote;
     }
 
-    function _setNewVotePoolData(
-        address pool,
-        VeBalance memory vote,
-        uint128 wTime
-    ) internal {
+    function _setNewVotePoolData(address pool, VeBalance memory vote, uint128 wTime) internal {
         poolData[pool].totalVote = vote;
         poolData[pool].lastSlopeChangeAppliedAt = wTime;
         emit PoolVoteChange(pool, vote);

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleMainchain.sol

@@ -75,10 +75,10 @@ contract VotingEscrowPendleMainchain is
      * @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);
@@ -146,11 +146,10 @@ 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);
     }
@@ -159,29 +158,24 @@ 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);
         }

package/contracts/LiquidityMining/VotingEscrow/VotingEscrowPendleSidechain.sol

@@ -24,10 +24,9 @@ contract VotingEscrowPendleSidechain is
 
     event SetNewUserPosition(LockedPosition position);
 
-    constructor(address _PendleMsgReceiveEndpointUpg)
-        initializer
-        PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg)
-    {
+    constructor(
+        address _PendleMsgReceiveEndpointUpg
+    ) initializer PendleMsgReceiverAppUpg(_PendleMsgReceiveEndpointUpg) {
         __BoringOwnable_init();
     }
 

package/contracts/LiquidityMining/libraries/VeBalanceLib.sol

@@ -17,22 +17,20 @@ struct LockedPosition {
 library VeBalanceLib {
     using Math for uint256;
     uint128 internal constant MAX_LOCK_TIME = 104 weeks;
-    uint256 internal constant USER_VOTE_MAX_WEIGHT = 10**18;
+    uint256 internal constant USER_VOTE_MAX_WEIGHT = 10 ** 18;
 
-    function add(VeBalance memory a, VeBalance memory b)
-        internal
-        pure
-        returns (VeBalance memory res)
-    {
+    function add(
+        VeBalance memory a,
+        VeBalance memory b
+    ) internal pure returns (VeBalance memory res) {
         res.bias = a.bias + b.bias;
         res.slope = a.slope + b.slope;
     }
 
-    function sub(VeBalance memory a, VeBalance memory b)
-        internal
-        pure
-        returns (VeBalance memory res)
-    {
+    function sub(
+        VeBalance memory a,
+        VeBalance memory b
+    ) internal pure returns (VeBalance memory res) {
         res.bias = a.bias - b.bias;
         res.slope = a.slope - b.slope;
     }
@@ -67,29 +65,25 @@ library VeBalanceLib {
         return a.bias / a.slope;
     }
 
-    function convertToVeBalance(LockedPosition memory position)
-        internal
-        pure
-        returns (VeBalance memory res)
-    {
+    function convertToVeBalance(
+        LockedPosition memory position
+    ) internal pure returns (VeBalance memory res) {
         res.slope = position.amount / MAX_LOCK_TIME;
         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;
     }
 
-    function convertToVeBalance(uint128 amount, uint128 expiry)
-        internal
-        pure
-        returns (uint128, uint128)
-    {
+    function convertToVeBalance(
+        uint128 amount,
+        uint128 expiry
+    ) internal pure returns (uint128, uint128) {
         VeBalance memory balance = convertToVeBalance(LockedPosition(amount, expiry));
         return (balance.bias, balance.slope);
     }

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -39,11 +39,7 @@ contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuard
     }
 
     // Since this contract is a beacon contract, no constructor should be defined.
-    function initialize(
-        address _token,
-        address _SY,
-        address _factory
-    ) external initializer {
+    function initialize(address _token, address _SY, address _factory) external initializer {
         __ReentrancyGuard_init();
         token = _token;
         SY = _SY;

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -37,11 +37,10 @@ contract BulkSellerFactory is
         upgradeBeacon(implementation_);
     }
 
-    function createBulkSeller(address token, address SY)
-        external
-        onlyMaintainer
-        returns (address bulk)
-    {
+    function createBulkSeller(
+        address token,
+        address SY
+    ) external onlyMaintainer returns (address bulk) {
         IStandardizedYield _SY = IStandardizedYield(SY);
         if (syToBulkSeller[token][SY] != address(0))
             revert Errors.BulkSellerAlreadyExisted(token, SY, syToBulkSeller[token][SY]);

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -16,31 +16,28 @@ struct BulkSellerState {
 library BulkSellerMathCore {
     using Math for uint256;
 
-    function swapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
-        internal
-        pure
-        returns (uint256 netSyOut)
-    {
+    function swapExactTokenForSy(
+        BulkSellerState memory state,
+        uint256 netTokenIn
+    ) internal pure returns (uint256 netSyOut) {
         netSyOut = calcSwapExactTokenForSy(state, netTokenIn);
         state.totalToken += netTokenIn;
         state.totalSy -= netSyOut;
     }
 
-    function swapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
-        internal
-        pure
-        returns (uint256 netTokenOut)
-    {
+    function swapExactSyForToken(
+        BulkSellerState memory state,
+        uint256 netSyIn
+    ) internal pure returns (uint256 netTokenOut) {
         netTokenOut = calcSwapExactSyForToken(state, netSyIn);
         state.totalSy += netSyIn;
         state.totalToken -= netTokenOut;
     }
 
-    function calcSwapExactTokenForSy(BulkSellerState memory state, uint256 netTokenIn)
-        internal
-        pure
-        returns (uint256 netSyOut)
-    {
+    function calcSwapExactTokenForSy(
+        BulkSellerState memory state,
+        uint256 netTokenIn
+    ) internal pure returns (uint256 netSyOut) {
         uint256 postFeeRate = state.rateTokenToSy.mulDown(Math.ONE - state.feeRate);
         assert(postFeeRate != 0);
 
@@ -49,11 +46,10 @@ library BulkSellerMathCore {
             revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
     }
 
-    function calcSwapExactSyForToken(BulkSellerState memory state, uint256 netSyIn)
-        internal
-        pure
-        returns (uint256 netTokenOut)
-    {
+    function calcSwapExactSyForToken(
+        BulkSellerState memory state,
+        uint256 netSyIn
+    ) internal pure returns (uint256 netTokenOut) {
         uint256 postFeeRate = state.rateSyToToken.mulDown(Math.ONE - state.feeRate);
         assert(postFeeRate != 0);
 
@@ -68,11 +64,10 @@ library BulkSellerMathCore {
         return totalToken.divDown(totalToken + totalTokenFromSy);
     }
 
-    function getReBalanceParams(BulkSellerState memory state, uint256 targetTokenProp)
-        internal
-        pure
-        returns (uint256 netTokenToDeposit, uint256 netSyToRedeem)
-    {
+    function getReBalanceParams(
+        BulkSellerState memory state,
+        uint256 targetTokenProp
+    ) internal pure returns (uint256 netTokenToDeposit, uint256 netSyToRedeem) {
         uint256 currentTokenProp = getTokenProp(state);
 
         if (currentTokenProp > targetTokenProp) {

package/contracts/core/Market/MarketMathCore.sol

@@ -38,7 +38,7 @@ library MarketMathCore {
     using LogExpMath for int256;
     using PYIndexLib for PYIndex;
 
-    int256 internal constant MINIMUM_LIQUIDITY = 10**3;
+    int256 internal constant MINIMUM_LIQUIDITY = 10 ** 3;
     int256 internal constant PERCENTAGE_DECIMALS = 100;
     uint256 internal constant DAY = 86400;
     uint256 internal constant IMPLIED_RATE_TIME = 365 * DAY;
@@ -60,12 +60,7 @@ library MarketMathCore {
     )
         internal
         pure
-        returns (
-            uint256 lpToReserve,
-            uint256 lpToAccount,
-            uint256 syUsed,
-            uint256 ptUsed
-        )
+        returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed)
     {
         (
             int256 _lpToReserve,
@@ -80,11 +75,10 @@ library MarketMathCore {
         ptUsed = _ptUsed.Uint();
     }
 
-    function removeLiquidity(MarketState memory market, uint256 lpToRemove)
-        internal
-        pure
-        returns (uint256 netSyToAccount, uint256 netPtToAccount)
-    {
+    function removeLiquidity(
+        MarketState memory market,
+        uint256 lpToRemove
+    ) internal pure returns (uint256 netSyToAccount, uint256 netPtToAccount) {
         (int256 _syToAccount, int256 _ptToAccount) = removeLiquidityCore(market, lpToRemove.Int());
 
         netSyToAccount = _syToAccount.Uint();
@@ -96,15 +90,7 @@ library MarketMathCore {
         PYIndex index,
         uint256 exactPtToMarket,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (
-            uint256 netSyToAccount,
-            uint256 netSyFee,
-            uint256 netSyToReserve
-        )
-    {
+    ) internal pure returns (uint256 netSyToAccount, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyToAccount, int256 _netSyFee, int256 _netSyToReserve) = executeTradeCore(
             market,
             index,
@@ -122,15 +108,7 @@ library MarketMathCore {
         PYIndex index,
         uint256 exactPtToAccount,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (
-            uint256 netSyToMarket,
-            uint256 netSyFee,
-            uint256 netSyToReserve
-        )
-    {
+    ) internal pure returns (uint256 netSyToMarket, uint256 netSyFee, uint256 netSyToReserve) {
         (int256 _netSyToAccount, int256 _netSyFee, int256 _netSyToReserve) = executeTradeCore(
             market,
             index,
@@ -155,12 +133,7 @@ library MarketMathCore {
     )
         internal
         pure
-        returns (
-            int256 lpToReserve,
-            int256 lpToAccount,
-            int256 syUsed,
-            int256 ptUsed
-        )
+        returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed)
     {
         /// ------------------------------------------------------------
         /// CHECKS
@@ -200,11 +173,10 @@ library MarketMathCore {
         market.totalLp += lpToAccount + lpToReserve;
     }
 
-    function removeLiquidityCore(MarketState memory market, int256 lpToRemove)
-        internal
-        pure
-        returns (int256 netSyToAccount, int256 netPtToAccount)
-    {
+    function removeLiquidityCore(
+        MarketState memory market,
+        int256 lpToRemove
+    ) internal pure returns (int256 netSyToAccount, int256 netPtToAccount) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -231,15 +203,7 @@ library MarketMathCore {
         PYIndex index,
         int256 netPtToAccount,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (
-            int256 netSyToAccount,
-            int256 netSyFee,
-            int256 netSyToReserve
-        )
-    {
+    ) internal pure returns (int256 netSyToAccount, int256 netSyFee, int256 netSyToReserve) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -303,15 +267,7 @@ library MarketMathCore {
         MarketPreCompute memory comp,
         PYIndex index,
         int256 netPtToAccount
-    )
-        internal
-        pure
-        returns (
-            int256 netSyToAccount,
-            int256 netSyFee,
-            int256 netSyToReserve
-        )
-    {
+    ) internal pure returns (int256 netSyToAccount, int256 netSyFee, int256 netSyToReserve) {
         int256 preFeeExchangeRate = _getExchangeRate(
             market.totalPt,
             comp.totalAsset,
@@ -408,11 +364,10 @@ library MarketMathCore {
 
     /// @notice Converts an implied rate to an exchange rate given a time to expiry. The
     /// formula is E = e^rt
-    function _getExchangeRateFromImpliedRate(uint256 lnImpliedRate, uint256 timeToExpiry)
-        internal
-        pure
-        returns (int256 exchangeRate)
-    {
+    function _getExchangeRateFromImpliedRate(
+        uint256 lnImpliedRate,
+        uint256 timeToExpiry
+    ) internal pure returns (int256 exchangeRate) {
         uint256 rt = (lnImpliedRate * timeToExpiry) / IMPLIED_RATE_TIME;
 
         exchangeRate = LogExpMath.exp(rt.Int());
@@ -447,11 +402,10 @@ library MarketMathCore {
         res = logitP.ln();
     }
 
-    function _getRateScalar(MarketState memory market, uint256 timeToExpiry)
-        internal
-        pure
-        returns (int256 rateScalar)
-    {
+    function _getRateScalar(
+        MarketState memory market,
+        uint256 timeToExpiry
+    ) internal pure returns (int256 rateScalar) {
         rateScalar = (market.scalarRoot * IMPLIED_RATE_TIME.Int()) / timeToExpiry.Int();
         if (rateScalar <= 0) revert Errors.MarketRateScalarBelowZero(rateScalar);
     }

package/contracts/core/Market/OracleLib.sol

@@ -28,10 +28,10 @@ library OracleLib {
             });
     }
 
-    function initialize(Observation[65535] storage self, uint32 time)
-        public
-        returns (uint16 cardinality, uint16 cardinalityNext)
-    {
+    function initialize(
+        Observation[65535] storage self,
+        uint32 time
+    ) public returns (uint16 cardinality, uint16 cardinalityNext) {
         self[0] = Observation({
             blockTimestamp: time,
             lnImpliedRateCumulative: 0,