@pendle/core-v2 3.0.0-beta-9 → 3.0.0

package/contracts/core/BulkSeller/BulkSeller.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../../interfaces/IPBulkSeller.sol";
+
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/PMath.sol";
+import "../libraries/Errors.sol";
+
+import "./BulkSellerMathCore.sol";
+
+contract BulkSeller is IPBulkSeller, Initializable, TokenHelper, ReentrancyGuardUpgradeable {
+    using PMath for uint256;
+    using SafeERC20 for IERC20;
+    using BulkSellerMathCore for BulkSellerState;
+
+    struct BulkSellerStorage {
+        uint128 rateTokenToSy;
+        uint128 rateSyToToken;
+        uint128 totalSy;
+        uint128 totalToken;
+    }
+
+    address public token;
+    address public SY;
+    uint64 public feeRate;
+
+    address public factory;
+    BulkSellerStorage public _storage;
+
+    modifier onlyMaintainer() {
+        if (!IPBulkSellerFactory(factory).isMaintainer(msg.sender)) revert Errors.BulkNotMaintainer();
+        _;
+    }
+
+    // Since this contract is a beacon contract, no constructor should be defined.
+    function initialize(address _token, address _SY, address _factory) external initializer {
+        __ReentrancyGuard_init();
+        token = _token;
+        SY = _SY;
+        factory = _factory;
+        _safeApproveInf(token, SY);
+    }
+
+    function swapExactTokenForSy(
+        address receiver,
+        uint256 netTokenIn,
+        uint256 minSyOut
+    ) external payable nonReentrant returns (uint256 netSyOut) {
+        BulkSellerState memory state = readState();
+
+        _transferIn(token, msg.sender, netTokenIn);
+
+        netSyOut = state.swapExactTokenForSy(netTokenIn);
+
+        if (netSyOut < minSyOut) revert Errors.BulkInSufficientSyOut(netSyOut, minSyOut);
+
+        _transferOut(SY, receiver, netSyOut);
+
+        _writeState(state);
+
+        emit SwapExactTokenForSy(receiver, netTokenIn, netSyOut);
+    }
+
+    function swapExactSyForToken(
+        address receiver,
+        uint256 exactSyIn,
+        uint256 minTokenOut,
+        bool swapFromInternalBalance
+    ) external nonReentrant returns (uint256 netTokenOut) {
+        BulkSellerState memory state = readState();
+
+        if (!swapFromInternalBalance) _transferIn(SY, msg.sender, exactSyIn);
+        else {
+            uint256 netSyReceived = _selfBalance(SY) - state.totalSy;
+            if (netSyReceived < exactSyIn) revert Errors.BulkInsufficientSyReceived(netSyReceived, exactSyIn);
+        }
+
+        netTokenOut = state.swapExactSyForToken(exactSyIn);
+
+        if (netTokenOut < minTokenOut) revert Errors.BulkInSufficientTokenOut(netTokenOut, minTokenOut);
+
+        _transferOut(token, receiver, netTokenOut);
+
+        _writeState(state);
+
+        emit SwapExactSyForToken(receiver, exactSyIn, netTokenOut);
+    }
+
+    function readState() public view returns (BulkSellerState memory state) {
+        BulkSellerStorage storage s = _storage;
+
+        state = BulkSellerState({
+            rateTokenToSy: s.rateTokenToSy,
+            rateSyToToken: s.rateSyToToken,
+            totalToken: s.totalToken,
+            totalSy: s.totalSy,
+            feeRate: feeRate
+        });
+    }
+
+    function _writeState(BulkSellerState memory state) internal {
+        BulkSellerStorage memory tmp = BulkSellerStorage({
+            rateTokenToSy: state.rateTokenToSy.Uint128(),
+            rateSyToToken: state.rateSyToToken.Uint128(),
+            totalSy: state.totalSy.Uint128(),
+            totalToken: state.totalToken.Uint128()
+        });
+
+        _storage = tmp;
+    }
+
+    // ----------------- BulkSeller management -----------------
+
+    function increaseReserve(uint256 netTokenIn, uint256 netSyIn) external payable onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        state.totalToken += netTokenIn;
+        state.totalSy += netSyIn;
+
+        _transferIn(token, msg.sender, netTokenIn);
+        _transferIn(SY, msg.sender, netSyIn);
+
+        emit ReserveUpdated(state.totalToken, state.totalSy);
+
+        _writeState(state);
+    }
+
+    function decreaseReserve(uint256 netTokenOut, uint256 netSyOut) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        if (netTokenOut == type(uint256).max) netTokenOut = state.totalToken;
+        if (netSyOut == type(uint256).max) netSyOut = state.totalSy;
+
+        state.totalToken -= netTokenOut;
+        state.totalSy -= netSyOut;
+
+        _transferOut(token, msg.sender, netTokenOut);
+        _transferOut(SY, msg.sender, netSyOut);
+
+        emit ReserveUpdated(state.totalToken, state.totalSy);
+
+        _writeState(state);
+    }
+
+    function redeemRewards() external onlyMaintainer {
+        IStandardizedYield(SY).claimRewards(address(this));
+        address[] memory rewardTokens = IStandardizedYield(SY).getRewardTokens();
+
+        for (uint256 i = 0; i < rewardTokens.length; i++) {
+            if (rewardTokens[i] == token) continue;
+            _transferOut(rewardTokens[i], msg.sender, _selfBalance(rewardTokens[i]));
+        }
+    }
+
+    function skim() external onlyMaintainer {
+        BulkSellerState memory state = readState();
+        uint256 excessToken = _selfBalance(token) - state.totalToken;
+        uint256 excessSy = _selfBalance(SY) - state.totalSy;
+        if (excessToken != 0) IERC20(token).safeTransfer(msg.sender, excessToken);
+        if (excessSy != 0) IERC20(SY).safeTransfer(msg.sender, excessSy);
+    }
+
+    function reBalance(uint256 targetProp, uint256 maxDiff) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+        uint256 oldTokenProp = state.getTokenProp();
+
+        (uint256 netTokenDeposit, uint256 netSyRedeem) = state.getReBalanceParams(targetProp);
+
+        if (netTokenDeposit > 0) {
+            uint256 netSyFromToken = _depositToken(netTokenDeposit);
+            state.reBalanceTokenToSy(netTokenDeposit, netSyFromToken, maxDiff);
+
+            uint256 newTokenProp = state.getTokenProp();
+            emit ReBalanceTokenToSy(netTokenDeposit, netSyFromToken, newTokenProp, oldTokenProp);
+        } else {
+            uint256 netTokenFromSy = _redeemSy(netSyRedeem);
+            state.reBalanceSyToToken(netSyRedeem, netTokenFromSy, maxDiff);
+
+            uint256 newTokenProp = state.getTokenProp();
+            emit ReBalanceSyToToken(netSyRedeem, netTokenFromSy, newTokenProp, oldTokenProp);
+        }
+
+        _writeState(state);
+    }
+
+    function setRate(uint256 newRateSyToToken, uint256 newRateTokenToSy, uint256 maxDiff) external onlyMaintainer {
+        BulkSellerState memory state = readState();
+
+        emit RateUpdated(newRateTokenToSy, newRateSyToToken, state.rateTokenToSy, state.rateSyToToken);
+
+        state.setRate(newRateSyToToken, newRateTokenToSy, maxDiff);
+
+        _writeState(state);
+    }
+
+    function setFeeRate(uint64 newFeeRate) external onlyMaintainer {
+        emit FeeRateUpdated(newFeeRate, feeRate);
+        feeRate = newFeeRate;
+    }
+
+    function _depositToken(uint256 netTokenDeposit) internal returns (uint256 netSyFromToken) {
+        uint256 nativeToDeposit = token == NATIVE ? netTokenDeposit : 0;
+        return IStandardizedYield(SY).deposit{value: nativeToDeposit}(address(this), token, netTokenDeposit, 0);
+    }
+
+    function _redeemSy(uint256 netSyRedeem) internal returns (uint256 netTokenFromSy) {
+        _transferOut(SY, SY, netSyRedeem);
+        return IStandardizedYield(SY).redeem(address(this), netSyRedeem, token, 0, true);
+    }
+}

package/contracts/core/BulkSeller/BulkSellerFactory.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "@openzeppelin/contracts/proxy/beacon/IBeacon.sol";
+import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "../libraries/BoringOwnableUpgradeable.sol";
+
+import "../../interfaces/IStandardizedYield.sol";
+import "../../interfaces/IPBulkSellerFactory.sol";
+import "../libraries/Errors.sol";
+
+contract BulkSellerFactory is IBeacon, IPBulkSellerFactory, Initializable, AccessControlUpgradeable, UUPSUpgradeable {
+    bytes32 public constant MAINTAINER = keccak256("MAINTAINER");
+
+    address public implementation;
+
+    mapping(address => mapping(address => address)) internal syToBulkSeller;
+
+    modifier onlyMaintainer() {
+        if (!isMaintainer(msg.sender)) revert Errors.BulkNotMaintainer();
+        _;
+    }
+
+    constructor() initializer {}
+
+    function initialize(address implementation_) external initializer {
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        upgradeBeacon(implementation_);
+    }
+
+    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]);
+        if (_SY.isValidTokenIn(token) == false || _SY.isValidTokenOut(token) == false)
+            revert Errors.BulkSellerInvalidToken(token, SY);
+
+        bytes memory data = abi.encodeWithSignature("initialize(address,address,address)", token, SY, address(this));
+
+        bulk = address(new BeaconProxy(address(this), data));
+
+        syToBulkSeller[token][SY] = bulk;
+
+        emit BulkSellerCreated(token, SY, bulk);
+
+        return bulk;
+    }
+
+    function get(address token, address SY) external view override returns (address) {
+        return syToBulkSeller[token][SY];
+    }
+
+    function isMaintainer(address addr) public view override returns (bool) {
+        return (hasRole(DEFAULT_ADMIN_ROLE, addr) || hasRole(MAINTAINER, addr));
+    }
+
+    // ----------------- upgrade-related -----------------
+    function upgradeBeacon(address newImplementation) public onlyMaintainer {
+        require(
+            AddressUpgradeable.isContract(newImplementation),
+            "UpgradeableBeacon: implementation is not a contract"
+        );
+        implementation = newImplementation;
+        emit UpgradedBeacon(newImplementation);
+    }
+
+    function _authorizeUpgrade(address) internal override onlyMaintainer {}
+}

package/contracts/core/BulkSeller/BulkSellerMathCore.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "../libraries/TokenHelper.sol";
+import "../libraries/math/PMath.sol";
+import "../libraries/Errors.sol";
+
+struct BulkSellerState {
+    uint256 rateTokenToSy;
+    uint256 rateSyToToken;
+    uint256 totalToken;
+    uint256 totalSy;
+    uint256 feeRate;
+}
+
+library BulkSellerMathCore {
+    using PMath for uint256;
+
+    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) {
+        netTokenOut = calcSwapExactSyForToken(state, netSyIn);
+        state.totalSy += netSyIn;
+        state.totalToken -= netTokenOut;
+    }
+
+    function calcSwapExactTokenForSy(
+        BulkSellerState memory state,
+        uint256 netTokenIn
+    ) internal pure returns (uint256 netSyOut) {
+        uint256 postFeeRate = state.rateTokenToSy.mulDown(PMath.ONE - state.feeRate);
+        assert(postFeeRate != 0);
+
+        netSyOut = netTokenIn.mulDown(postFeeRate);
+        if (netSyOut > state.totalSy) revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
+    }
+
+    function calcSwapExactSyForToken(
+        BulkSellerState memory state,
+        uint256 netSyIn
+    ) internal pure returns (uint256 netTokenOut) {
+        uint256 postFeeRate = state.rateSyToToken.mulDown(PMath.ONE - state.feeRate);
+        assert(postFeeRate != 0);
+
+        netTokenOut = netSyIn.mulDown(postFeeRate);
+        if (netTokenOut > state.totalToken) revert Errors.BulkInsufficientTokenForTrade(state.totalToken, netTokenOut);
+    }
+
+    function getTokenProp(BulkSellerState memory state) internal pure returns (uint256) {
+        uint256 totalToken = state.totalToken;
+        uint256 totalTokenFromSy = state.totalSy.mulDown(state.rateSyToToken);
+        return totalToken.divDown(totalToken + totalTokenFromSy);
+    }
+
+    function getReBalanceParams(
+        BulkSellerState memory state,
+        uint256 targetTokenProp
+    ) internal pure returns (uint256 netTokenToDeposit, uint256 netSyToRedeem) {
+        uint256 currentTokenProp = getTokenProp(state);
+
+        if (currentTokenProp > targetTokenProp) {
+            netTokenToDeposit = state.totalToken.mulDown(currentTokenProp - targetTokenProp).divDown(currentTokenProp);
+        } else {
+            uint256 currentSyProp = PMath.ONE - currentTokenProp;
+            netSyToRedeem = state.totalSy.mulDown(targetTokenProp - currentTokenProp).divDown(currentSyProp);
+        }
+    }
+
+    function reBalanceTokenToSy(
+        BulkSellerState memory state,
+        uint256 netTokenToDeposit,
+        uint256 netSyFromToken,
+        uint256 maxDiff
+    ) internal pure {
+        uint256 rate = netSyFromToken.divDown(netTokenToDeposit);
+
+        if (!PMath.isAApproxB(rate, state.rateTokenToSy, maxDiff))
+            revert Errors.BulkBadRateTokenToSy(rate, state.rateTokenToSy, maxDiff);
+
+        state.totalToken -= netTokenToDeposit;
+        state.totalSy += netSyFromToken;
+    }
+
+    function reBalanceSyToToken(
+        BulkSellerState memory state,
+        uint256 netSyToRedeem,
+        uint256 netTokenFromSy,
+        uint256 maxDiff
+    ) internal pure {
+        uint256 rate = netTokenFromSy.divDown(netSyToRedeem);
+
+        if (!PMath.isAApproxB(rate, state.rateSyToToken, maxDiff))
+            revert Errors.BulkBadRateSyToToken(rate, state.rateSyToToken, maxDiff);
+
+        state.totalToken += netTokenFromSy;
+        state.totalSy -= netSyToRedeem;
+    }
+
+    function setRate(
+        BulkSellerState memory state,
+        uint256 rateSyToToken,
+        uint256 rateTokenToSy,
+        uint256 maxDiff
+    ) internal pure {
+        if (state.rateTokenToSy != 0 && !PMath.isAApproxB(rateTokenToSy, state.rateTokenToSy, maxDiff)) {
+            revert Errors.BulkBadRateTokenToSy(rateTokenToSy, state.rateTokenToSy, maxDiff);
+        }
+
+        if (state.rateSyToToken != 0 && !PMath.isAApproxB(rateSyToToken, state.rateSyToToken, maxDiff)) {
+            revert Errors.BulkBadRateSyToToken(rateSyToToken, state.rateSyToToken, maxDiff);
+        }
+
+        state.rateTokenToSy = rateTokenToSy;
+        state.rateSyToToken = rateSyToToken;
+    }
+}

package/contracts/core/Market/MarketMathCore.sol

@@ -57,17 +57,13 @@ library MarketMathCore {
         uint256 syDesired,
         uint256 ptDesired,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed)
-    {
-        (
-            int256 _lpToReserve,
-            int256 _lpToAccount,
-            int256 _syUsed,
-            int256 _ptUsed
-        ) = addLiquidityCore(market, syDesired.Int(), ptDesired.Int(), blockTime);
+    ) internal pure returns (uint256 lpToReserve, uint256 lpToAccount, uint256 syUsed, uint256 ptUsed) {
+        (int256 _lpToReserve, int256 _lpToAccount, int256 _syUsed, int256 _ptUsed) = addLiquidityCore(
+            market,
+            syDesired.Int(),
+            ptDesired.Int(),
+            blockTime
+        );
 
         lpToReserve = _lpToReserve.Uint();
         lpToAccount = _lpToAccount.Uint();
@@ -130,11 +126,7 @@ library MarketMathCore {
         int256 syDesired,
         int256 ptDesired,
         uint256 blockTime
-    )
-        internal
-        pure
-        returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed)
-    {
+    ) internal pure returns (int256 lpToReserve, int256 lpToAccount, int256 syUsed, int256 ptUsed) {
         /// ------------------------------------------------------------
         /// CHECKS
         /// ------------------------------------------------------------
@@ -216,25 +208,12 @@ library MarketMathCore {
         /// ------------------------------------------------------------
         MarketPreCompute memory comp = getMarketPreCompute(market, index, blockTime);
 
-        (netSyToAccount, netSyFee, netSyToReserve) = calcTrade(
-            market,
-            comp,
-            index,
-            netPtToAccount
-        );
+        (netSyToAccount, netSyFee, netSyToReserve) = calcTrade(market, comp, index, netPtToAccount);
 
         /// ------------------------------------------------------------
         /// WRITE
         /// ------------------------------------------------------------
-        _setNewMarketStateTrade(
-            market,
-            comp,
-            index,
-            netPtToAccount,
-            netSyToAccount,
-            netSyToReserve,
-            blockTime
-        );
+        _setNewMarketStateTrade(market, comp, index, netPtToAccount, netSyToAccount, netSyToReserve, blockTime);
     }
 
     function getMarketPreCompute(
@@ -281,8 +260,7 @@ library MarketMathCore {
 
         if (netPtToAccount > 0) {
             int256 postFeeExchangeRate = preFeeExchangeRate.divDown(fee);
-            if (postFeeExchangeRate < PMath.IONE)
-                revert Errors.MarketExchangeRateBelowOne(postFeeExchangeRate);
+            if (postFeeExchangeRate < PMath.IONE) revert Errors.MarketExchangeRateBelowOne(postFeeExchangeRate);
 
             fee = preFeeAssetToAccount.mulDown(PMath.IONE - fee);
         } else {
@@ -402,10 +380,7 @@ 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

@@ -32,11 +32,7 @@ library OracleLib {
         Observation[65535] storage self,
         uint32 time
     ) public returns (uint16 cardinality, uint16 cardinalityNext) {
-        self[0] = Observation({
-            blockTimestamp: time,
-            lnImpliedRateCumulative: 0,
-            initialized: true
-        });
+        self[0] = Observation({blockTimestamp: time, lnImpliedRateCumulative: 0, initialized: true});
         return (1, 1);
     }
 
@@ -64,11 +60,7 @@ library OracleLib {
         self[indexUpdated] = transform(last, blockTimestamp, lnImpliedRate);
     }
 
-    function grow(
-        Observation[65535] storage self,
-        uint16 current,
-        uint16 next
-    ) public returns (uint16) {
+    function grow(Observation[65535] storage self, uint16 current, uint16 next) public returns (uint16) {
         if (current == 0) revert Errors.OracleUninitialized();
         // no-op if the passed next value isn't greater than the current next value
         if (next <= current) return current;
@@ -141,8 +133,7 @@ library OracleLib {
         if (!beforeOrAt.initialized) beforeOrAt = self[0];
 
         // ensure that the target is chronologically at or after the oldest observation
-        if (target < beforeOrAt.blockTimestamp)
-            revert Errors.OracleTargetTooOld(target, beforeOrAt.blockTimestamp);
+        if (target < beforeOrAt.blockTimestamp) revert Errors.OracleTargetTooOld(target, beforeOrAt.blockTimestamp);
 
         // if we've reached this point, we have to binary search
         return binarySearch(self, target, index, cardinality);
@@ -184,10 +175,8 @@ library OracleLib {
             // we're in the middle
             return (beforeOrAt.lnImpliedRateCumulative +
                 uint216(
-                    (uint256(
-                        atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative
-                    ) * (target - beforeOrAt.blockTimestamp)) /
-                        (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
+                    (uint256(atOrAfter.lnImpliedRateCumulative - beforeOrAt.lnImpliedRateCumulative) *
+                        (target - beforeOrAt.blockTimestamp)) / (atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp)
                 ));
         }
     }
@@ -204,14 +193,7 @@ library OracleLib {
 
         lnImpliedRateCumulative = new uint216[](secondsAgos.length);
         for (uint256 i = 0; i < lnImpliedRateCumulative.length; ++i) {
-            lnImpliedRateCumulative[i] = observeSingle(
-                self,
-                time,
-                secondsAgos[i],
-                lnImpliedRate,
-                index,
-                cardinality
-            );
+            lnImpliedRateCumulative[i] = observeSingle(self, time, secondsAgos[i], lnImpliedRate, index, cardinality);
         }
     }
 }

package/contracts/core/Market/PendleExternalRewardDistributor.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/utils/structs/EnumerableSet.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../libraries/math/PMath.sol";
@@ -28,8 +28,7 @@ contract PendleExternalRewardDistributor is
 
     modifier onlyValidMarket(address market) {
         require(
-            IPMarketFactory(marketFactory).isValidMarket(market) &&
-                block.timestamp < IPMarket(market).expiry(),
+            IPMarketFactory(marketFactory).isValidMarket(market) && block.timestamp < IPMarket(market).expiry(),
             "invalid market"
         );
         _;
@@ -43,9 +42,7 @@ contract PendleExternalRewardDistributor is
         __BoringOwnable_init();
     }
 
-    function getRewardTokens(
-        address market
-    ) external view returns (address[] memory) {
+    function getRewardTokens(address market) external view returns (address[] memory) {
         return rewardTokens[market];
     }
 
@@ -120,10 +117,7 @@ contract PendleExternalRewardDistributor is
         emit AddRewardToMarket(market, token, rewardData[market][token]);
     }
 
-    function _getUpdatedMarketReward(
-        address market,
-        address token
-    ) internal view returns (MarketRewardData memory) {
+    function _getUpdatedMarketReward(address market, address token) internal view returns (MarketRewardData memory) {
         MarketRewardData memory rwd = rewardData[market][token];
         uint128 newLastUpdated = uint128(PMath.min(uint128(block.timestamp), rwd.incentiveEndsAt));
         rwd.accumulatedReward += rwd.rewardPerSec * (newLastUpdated - rwd.lastUpdated);

package/contracts/core/Market/PendleGauge.sol

@@ -71,19 +71,13 @@ abstract contract PendleGauge is RewardManager, IPGauge {
         activeBalance[user] = newActiveBalance;
     }
 
-    function _calcVeBoostedLpBalance(
-        address user,
-        uint256 lpBalance
-    ) internal virtual returns (uint256) {
-        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(
-            user
-        );
+    function _calcVeBoostedLpBalance(address user, uint256 lpBalance) internal virtual returns (uint256) {
+        (uint256 vePendleSupply, uint256 vePendleBalance) = vePENDLE.totalSupplyAndBalanceCurrent(user);
         // Inspired by Curve's Gauge
         uint256 veBoostedLpBalance = (lpBalance * TOKENLESS_PRODUCTION) / 100;
         if (vePendleSupply > 0) {
             veBoostedLpBalance +=
-                (((_totalStaked() * vePendleBalance) / vePendleSupply) *
-                    (100 - TOKENLESS_PRODUCTION)) /
+                (((_totalStaked() * vePendleBalance) / vePendleSupply) * (100 - TOKENLESS_PRODUCTION)) /
                 100;
         }
         return veBoostedLpBalance;