@pendle/core-v2 2.29.4 → 2.30.1

package/contracts/core/StandardizedYield/implementations/BenQi/PendleQiTokenSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../SYBaseWithRewards.sol";
 import "../../../../interfaces/IQiErc20.sol";
@@ -23,10 +23,7 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
         bool isUnderlyingNative,
         address _WAVAX,
         uint256 _initialExchangeRateMantissa
-    )
-        SYBaseWithRewards(_name, _symbol, _qiToken)
-        PendleQiTokenHelper(_qiToken, _initialExchangeRateMantissa)
-    {
+    ) SYBaseWithRewards(_name, _symbol, _qiToken) PendleQiTokenHelper(_qiToken, _initialExchangeRateMantissa) {
         qiToken = _qiToken;
 
         underlying = isUnderlyingNative ? NATIVE : IQiErc20(qiToken).underlying();
@@ -50,10 +47,7 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
      *
      * The exchange rate of qiToken to shares is 1:1
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount) internal override returns (uint256 amountSharesOut) {
         if (tokenIn == qiToken) {
             amountSharesOut = amount;
         } else {
@@ -61,7 +55,7 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
             uint256 preBalanceQiToken = _selfBalance(qiToken);
 
             if (underlying == NATIVE) {
-                IQiAvax(qiToken).mint{ value: amount }();
+                IQiAvax(qiToken).mint{value: amount}();
             } else {
                 uint256 errCode = IQiErc20(qiToken).mint(amount);
                 if (errCode != 0) revert Errors.SYQiTokenMintFailed(errCode);
@@ -135,19 +129,13 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
         IBenQiComptroller(comptroller).claimReward(0, holders, qiTokens, false, true);
         IBenQiComptroller(comptroller).claimReward(1, holders, qiTokens, false, true);
 
-        uint256 rewardAccruedType0 = IBenQiComptroller(comptroller).rewardAccrued(
-            0,
-            address(this)
-        );
-        uint256 rewardAccruedType1 = IBenQiComptroller(comptroller).rewardAccrued(
-            1,
-            address(this)
-        );
+        uint256 rewardAccruedType0 = IBenQiComptroller(comptroller).rewardAccrued(0, address(this));
+        uint256 rewardAccruedType1 = IBenQiComptroller(comptroller).rewardAccrued(1, address(this));
 
         if (rewardAccruedType0 > 0 || rewardAccruedType1 > 0)
             revert Errors.SYQiTokenRedeemRewardsFailed(rewardAccruedType0, rewardAccruedType1);
 
-        if (address(this).balance != 0) IWETH(WAVAX).deposit{ value: address(this).balance }();
+        if (address(this).balance != 0) IWETH(WAVAX).deposit{value: address(this).balance}();
     }
 
     /*///////////////////////////////////////////////////////////////
@@ -190,15 +178,7 @@ contract PendleQiTokenSY is SYBaseWithRewards, PendleQiTokenHelper {
         return token == qiToken || token == underlying;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
-        return (
-            AssetType.TOKEN,
-            underlying,
-            underlying == NATIVE ? 18 : IERC20Metadata(underlying).decimals()
-        );
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, underlying, underlying == NATIVE ? 18 : IERC20Metadata(underlying).decimals());
     }
 }

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotRewardHelper.sol

@@ -103,9 +103,7 @@ contract CamelotRewardHelper is TokenHelper, ICamelotNFTHandler {
         return true;
     }
 
-    function _increaseNftPoolPosition(
-        uint256 amountLp
-    ) internal returns (uint256 amountLpAccountedForUser) {
+    function _increaseNftPoolPosition(uint256 amountLp) internal returns (uint256 amountLpAccountedForUser) {
         // first time minting from this contract
         if (positionId == POSITION_UNINITIALIZED) {
             positionId = ICamelotNFTPool(nftPool).lastTokenId() + 1;
@@ -175,11 +173,7 @@ contract CamelotRewardHelper is TokenHelper, ICamelotNFTHandler {
         return true;
     }
 
-    function onNFTWithdraw(
-        address,
-        uint256 tokenId,
-        uint256
-    ) external view ensureValidTokenId(tokenId) returns (bool) {
+    function onNFTWithdraw(address, uint256 tokenId, uint256) external view ensureValidTokenId(tokenId) returns (bool) {
         return true;
     }
 }

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatileCommon.sol

@@ -25,11 +25,7 @@ contract CamelotV1VolatileCommon {
     uint256 internal constant FOUR = 4 * FEE_DENOMINATOR;
 
     // reference: https://blog.alphaventuredao.io/onesideduniswap/
-    function _getZapInSwapAmount(
-        uint256 amountIn,
-        uint256 reserve,
-        uint256 fee
-    ) internal pure returns (uint256) {
+    function _getZapInSwapAmount(uint256 amountIn, uint256 reserve, uint256 fee) internal pure returns (uint256) {
         return
             (PMath.sqrt(PMath.square((TWO - fee) * reserve) + FOUR * (ONE - fee) * amountIn * reserve) -
                 (TWO - fee) *

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatileLpHelper.sol

@@ -24,11 +24,7 @@ abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCom
     address public immutable pair;
     address public immutable router;
 
-
-    constructor(
-        address _pair,
-        address _router
-    ) {
+    constructor(address _pair, address _router) {
         assert(ICamelotPair(_pair).stableSwap() == false);
         pair = _pair;
         router = _router;
@@ -58,12 +54,11 @@ abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCom
         }
     }
 
-    function _swapZapIn(address tokenIn, uint256 amountIn)
-        private
-        returns (uint256 amount0ToAddLiq, uint256 amount1ToAddLiq)
-    {
-        (uint256 reserve0, uint256 reserve1, uint256 fee0, uint256 fee1) = ICamelotPair(pair)
-            .getReserves();
+    function _swapZapIn(
+        address tokenIn,
+        uint256 amountIn
+    ) private returns (uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) {
+        (uint256 reserve0, uint256 reserve1, uint256 fee0, uint256 fee1) = ICamelotPair(pair).getReserves();
 
         if (tokenIn == token0) {
             uint256 amount0ToSwap = _getZapInSwapAmount(amountIn, reserve0, fee0);
@@ -82,10 +77,7 @@ abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCom
      * ==================================================================
      */
 
-    function _addLiquidity(uint256 amount0ToAddLiq, uint256 amount1ToAddLiq)
-        private
-        returns (uint256 amountLpOut)
-    {
+    function _addLiquidity(uint256 amount0ToAddLiq, uint256 amount1ToAddLiq) private returns (uint256 amountLpOut) {
         (, , amountLpOut) = ICamelotRouter(router).addLiquidity(
             token0,
             token1,
@@ -98,10 +90,7 @@ abstract contract CamelotV1VolatileLpHelper is TokenHelper, CamelotV1VolatileCom
         );
     }
 
-    function _removeLiquidity(uint256 amountLpToRemove)
-        private
-        returns (uint256 amountTokenA, uint256 amountTokenB)
-    {
+    function _removeLiquidity(uint256 amountLpToRemove) private returns (uint256 amountTokenA, uint256 amountTokenB) {
         return
             ICamelotRouter(router).removeLiquidity(
                 token0,

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/CamelotV1VolatilePreview.sol

@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./CamelotV1VolatileCommon.sol";
 
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../../../libraries/BoringOwnableUpgradeable.sol";
 
-contract CamelotV1VolatilePreview is
-    CamelotV1VolatileCommon,
-    BoringOwnableUpgradeable,
-    UUPSUpgradeable
-{
+contract CamelotV1VolatilePreview is CamelotV1VolatileCommon, BoringOwnableUpgradeable, UUPSUpgradeable {
     address internal immutable factory;
 
     constructor(address _factory) initializer {
@@ -84,11 +80,9 @@ contract CamelotV1VolatilePreview is
         data.reserve1 -= amount1Removed;
 
         if (tokenOut == data.token0) {
-            return
-                amount0Removed + _getSwapAmountOut(data, amount1Removed, data.token1, data.fee1);
+            return amount0Removed + _getSwapAmountOut(data, amount1Removed, data.token1, data.fee1);
         } else {
-            return
-                amount1Removed + _getSwapAmountOut(data, amount0Removed, data.token0, data.fee0);
+            return amount1Removed + _getSwapAmountOut(data, amount0Removed, data.token0, data.fee0);
         }
     }
 
@@ -131,26 +125,14 @@ contract CamelotV1VolatilePreview is
         }
 
         uint256 supply = _getTotalSupplyAfterMintFee(data);
-        return
-            PMath.min(
-                (amount0ToAddLiq * supply) / data.reserve0,
-                (amount1ToAddLiq * supply) / data.reserve1
-            );
+        return PMath.min((amount0ToAddLiq * supply) / data.reserve0, (amount1ToAddLiq * supply) / data.reserve1);
     }
 
-    function _quote(
-        uint256 amountA,
-        uint256 reserveA,
-        uint256 reserveB
-    ) private pure returns (uint256 amountB) {
+    function _quote(uint256 amountA, uint256 reserveA, uint256 reserveB) private pure returns (uint256 amountB) {
         amountB = (amountA * reserveB) / reserveA;
     }
 
-    function _getTotalSupplyAfterMintFee(CamelotPairData memory data)
-        private
-        view
-        returns (uint256)
-    {
+    function _getTotalSupplyAfterMintFee(CamelotPairData memory data) private view returns (uint256) {
         (uint256 ownerFeeShare, address feeTo) = ICamelotFactory(factory).feeInfo();
         bool feeOn = feeTo != address(0);
         uint256 _kLast = ICamelotPair(data.pair).kLast();

package/contracts/core/StandardizedYield/implementations/CamelotV1Volatile/PendleCamelotV1VolatileSY.sol

@@ -1,17 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./CamelotRewardHelper.sol";
 import "../../SYBaseWithRewards.sol";
 import "./CamelotV1VolatilePreview.sol";
 import "./CamelotV1VolatileLpHelper.sol";
 
-contract PendleCamelotV1VolatileSY is
-    SYBaseWithRewards,
-    CamelotRewardHelper,
-    CamelotV1VolatileLpHelper
-{
+contract PendleCamelotV1VolatileSY is SYBaseWithRewards, CamelotRewardHelper, CamelotV1VolatileLpHelper {
     using PMath for uint256;
     using ArrayLib for address[];
 
@@ -41,10 +37,7 @@ contract PendleCamelotV1VolatileSY is
     /**
      * @dev See {SYBase-_deposit}
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amountDeposited
-    ) internal virtual override returns (uint256) {
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
         uint256 amountLpDeposited;
         if (tokenIn == pair) {
             amountLpDeposited = amountDeposited;
@@ -106,10 +99,8 @@ contract PendleCamelotV1VolatileSY is
         address token1 = ICamelotNitroPool(nitroPool).rewardsToken1().token;
         address token2 = ICamelotNitroPool(nitroPool).rewardsToken2().token;
 
-        if (token1 != address(0) && token1 != xGRAIL && !rewardTokens.contains(token1))
-            rewardTokens.push(token1);
-        if (token2 != address(0) && token2 != xGRAIL && !rewardTokens.contains(token2))
-            rewardTokens.push(token2);
+        if (token1 != address(0) && token1 != xGRAIL && !rewardTokens.contains(token1)) rewardTokens.push(token1);
+        if (token2 != address(0) && token2 != xGRAIL && !rewardTokens.contains(token2)) rewardTokens.push(token2);
     }
 
     function _redeemExternalReward() internal override {
@@ -128,10 +119,7 @@ contract PendleCamelotV1VolatileSY is
                     PREVIEW-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function _previewDeposit(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal view override returns (uint256) {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
         if (tokenIn == pair) {
             return amountTokenToDeposit;
         } else {
@@ -139,10 +127,7 @@ contract PendleCamelotV1VolatileSY is
         }
     }
 
-    function _previewRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view override returns (uint256) {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
         if (tokenOut == pair) {
             return amountSharesToRedeem;
         } else {
@@ -183,11 +168,7 @@ contract PendleCamelotV1VolatileSY is
         return token == token0 || token == token1 || token == pair;
     }
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.LIQUIDITY, pair, IERC20Metadata(pair).decimals());
     }
 

package/contracts/core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkReceiver.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "../../../libraries/Errors.sol";
 import "../../../../LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol";
@@ -37,7 +37,7 @@ contract PendleChainlinkReceiver is Initializable {
     function lzReceive(
         uint16 _srcChainId,
         bytes calldata _path,
-        uint64, /*_nonce*/
+        uint64 /*_nonce*/,
         bytes calldata _payload
     ) external onlyLzEndpoint mustOriginateFromTrustedRemote(_srcChainId, _path) {
         int256 rate = abi.decode(_payload, (int256));

package/contracts/core/StandardizedYield/implementations/ChainlinkRelayer/PendleChainlinkRelayer.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "@openzeppelin/contracts/utils/Address.sol";
-import { AggregatorV2V3Interface as IChainlinkAggregator } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
+import {AggregatorV2V3Interface as IChainlinkAggregator} from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV2V3Interface.sol";
 
 import "../../../../LiquidityMining/CrossChainMsg/libraries/LayerZeroHelper.sol";
 import "../../../../interfaces/ILayerZeroEndpoint.sol";
@@ -17,12 +17,7 @@ contract PendleChainlinkRelayer {
     uint256 public immutable dstChainId;
     address public immutable chainlinkFeed;
 
-    constructor(
-        address _lzEndpoint,
-        address _dstAddress,
-        uint256 _dstChainId,
-        address _chainlinkFeed
-    ) {
+    constructor(address _lzEndpoint, address _dstAddress, uint256 _dstChainId, address _chainlinkFeed) {
         lzEndpoint = _lzEndpoint;
         dstAddress = _dstAddress;
         dstChainId = _dstChainId;
@@ -31,7 +26,7 @@ contract PendleChainlinkRelayer {
 
     function run() external payable {
         bytes memory path = abi.encodePacked(dstAddress, address(this));
-        ILayerZeroEndpoint(lzEndpoint).send{ value: msg.value }(
+        ILayerZeroEndpoint(lzEndpoint).send{value: msg.value}(
             LayerZeroHelper._getLayerZeroChainIds(dstChainId),
             path,
             abi.encode(IChainlinkAggregator(chainlinkFeed).latestAnswer()),

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveFraxUsdcSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./base/PendleConvexLPSY.sol";
 import "./base/CurveFraxUsdcPoolHelper.sol";
@@ -16,15 +16,7 @@ contract PendleCurveFraxUsdcSY is PendleConvexLPSY {
     constructor(
         string memory _name,
         string memory _symbol
-    )
-        PendleConvexLPSY(
-            _name,
-            _symbol,
-            PID,
-            CurveFraxUsdcPoolHelper.LP,
-            CurveFraxUsdcPoolHelper.POOL
-        )
-    {
+    ) PendleConvexLPSY(_name, _symbol, PID, CurveFraxUsdcPoolHelper.LP, CurveFraxUsdcPoolHelper.POOL) {
         _safeApproveInf(FRAX, crvPool);
         _safeApproveInf(USDC, crvPool);
     }
@@ -60,11 +52,7 @@ contract PendleCurveFraxUsdcSY is PendleConvexLPSY {
         address tokenOut,
         uint256 amountLpToRedeem
     ) internal view virtual override returns (uint256) {
-        return
-            ICrvPool(crvPool).calc_withdraw_one_coin(
-                amountLpToRedeem,
-                PMath.Int128(_getIndex(tokenOut))
-            );
+        return ICrvPool(crvPool).calc_withdraw_one_coin(amountLpToRedeem, PMath.Int128(_getIndex(tokenOut)));
     }
 
     function _getIndex(address token) internal pure returns (uint256) {

package/contracts/core/StandardizedYield/implementations/Convex/PendleCurveUsdd3CrvSY.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.17;
+pragma solidity ^0.8.17;
 
 import "./base/PendleConvexLPSY.sol";
 import "./base/CurveUsdd3CrvPoolHelper.sol";
@@ -20,15 +20,7 @@ contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
     constructor(
         string memory _name,
         string memory _symbol
-    )
-        PendleConvexLPSY(
-            _name,
-            _symbol,
-            PID,
-            CurveUsdd3CrvPoolHelper.POOL,
-            CurveUsdd3CrvPoolHelper.POOL
-        )
-    {
+    ) PendleConvexLPSY(_name, _symbol, PID, CurveUsdd3CrvPoolHelper.POOL, CurveUsdd3CrvPoolHelper.POOL) {
         _safeApproveInf(USDD, crvPool);
         _safeApproveInf(LP_3CRV, crvPool);
         _safeApproveInf(DAI, POOL_3CRV);
@@ -65,11 +57,7 @@ contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
 
         uint256 preBalanceToken = _selfBalance(tokenToRemove);
 
-        ICrvPool(crvPool).remove_liquidity_one_coin(
-            amountLpToRedeem,
-            PMath.Int128(_getIndex(tokenToRemove)),
-            0
-        );
+        ICrvPool(crvPool).remove_liquidity_one_coin(amountLpToRedeem, PMath.Int128(_getIndex(tokenToRemove)), 0);
 
         uint256 amountTokenRemoved = _selfBalance(tokenToRemove) - preBalanceToken;
 
@@ -131,17 +119,11 @@ contract PendleCurveUsdd3CrvSY is PendleConvexLPSY {
     }
 
     function isValidTokenIn(address token) public view virtual override returns (bool res) {
-        res = (token == crvLp ||
-            token == USDD ||
-            token == LP_3CRV ||
-            Curve3CrvPoolHelper.is3CrvToken(token));
+        res = (token == crvLp || token == USDD || token == LP_3CRV || Curve3CrvPoolHelper.is3CrvToken(token));
     }
 
     function isValidTokenOut(address token) public view override returns (bool res) {
-        res = (token == crvLp ||
-            token == USDD ||
-            token == LP_3CRV ||
-            Curve3CrvPoolHelper.is3CrvToken(token));
+        res = (token == crvLp || token == USDD || token == LP_3CRV || Curve3CrvPoolHelper.is3CrvToken(token));
     }
 
     function _getRewardTokens() internal pure override returns (address[] memory rewardTokens) {

package/contracts/core/StandardizedYield/implementations/Convex/base/Curve3CrvPoolHelper.sol

@@ -23,45 +23,25 @@ library Curve3CrvPoolHelper {
 
     // previewDeposit at the end of the file
 
-    function preview3CrvRedeem(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal view returns (uint256) {
-        return
-            ITriCrvPool(POOL).calc_withdraw_one_coin(
-                amountSharesToRedeem,
-                _get3CrvTokenIndex(tokenOut).Int128()
-            );
+    function preview3CrvRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view returns (uint256) {
+        return ITriCrvPool(POOL).calc_withdraw_one_coin(amountSharesToRedeem, _get3CrvTokenIndex(tokenOut).Int128());
     }
 
-    function deposit3Crv(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal returns (uint256) {
+    function deposit3Crv(address tokenIn, uint256 amountTokenToDeposit) internal returns (uint256) {
         uint256 balBefore = IERC20(LP).balanceOf(address(this));
         ITriCrvPool(POOL).add_liquidity(_getTokenAmounts(tokenIn, amountTokenToDeposit), 0);
         uint256 balAfter = IERC20(LP).balanceOf(address(this));
         return balAfter - balBefore;
     }
 
-    function redeem3Crv(
-        address tokenOut,
-        uint256 amountSharesToRedeem
-    ) internal returns (uint256) {
+    function redeem3Crv(address tokenOut, uint256 amountSharesToRedeem) internal returns (uint256) {
         uint256 balBefore = IERC20(tokenOut).balanceOf(address(this));
-        ITriCrvPool(POOL).remove_liquidity_one_coin(
-            amountSharesToRedeem,
-            _get3CrvTokenIndex(tokenOut).Int128(),
-            0
-        );
+        ITriCrvPool(POOL).remove_liquidity_one_coin(amountSharesToRedeem, _get3CrvTokenIndex(tokenOut).Int128(), 0);
         uint256 balAfter = IERC20(tokenOut).balanceOf(address(this));
         return balAfter - balBefore;
     }
 
-    function _getTokenAmounts(
-        address token,
-        uint256 amount
-    ) internal pure returns (uint256[N_COINS] memory res) {
+    function _getTokenAmounts(address token, uint256 amount) internal pure returns (uint256[N_COINS] memory res) {
         res[_get3CrvTokenIndex(token)] = amount;
     }
 
@@ -128,10 +108,7 @@ library Curve3CrvPoolHelper {
         }
 
         netLpOut = (token_supply * (D2 - D0)) / D0;
-        new_virtual_price = _get_virtual_price_with_balances(
-            self_balances,
-            token_supply + netLpOut
-        );
+        new_virtual_price = _get_virtual_price_with_balances(self_balances, token_supply + netLpOut);
     }
 
     function _get_virtual_price_with_balances(
@@ -143,16 +120,11 @@ library Curve3CrvPoolHelper {
         return (D * PRECISION) / token_supply;
     }
 
-    function get_D_mem(
-        uint256[N_COINS] memory balances,
-        uint256 amp
-    ) internal pure returns (uint256) {
+    function get_D_mem(uint256[N_COINS] memory balances, uint256 amp) internal pure returns (uint256) {
         return get_D(_xp_mem(balances), amp);
     }
 
-    function _xp_mem(
-        uint256[N_COINS] memory balances
-    ) internal pure returns (uint256[N_COINS] memory) {
+    function _xp_mem(uint256[N_COINS] memory balances) internal pure returns (uint256[N_COINS] memory) {
         uint256[N_COINS] memory result;
         result[0] = (RATE_0 * balances[0]) / PRECISION;
         result[1] = (RATE_1 * balances[1]) / PRECISION;
@@ -197,9 +169,7 @@ library Curve3CrvPoolHelper {
         balances[2] = ITriCrvPool(POOL).balances(2);
     }
 
-    function arrayClone(
-        uint256[N_COINS] memory a
-    ) internal pure returns (uint256[N_COINS] memory res) {
+    function arrayClone(uint256[N_COINS] memory a) internal pure returns (uint256[N_COINS] memory res) {
         for (uint256 i = 0; i < N_COINS; ++i) {
             res[i] = a[i];
         }

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveFraxUsdcPoolHelper.sol

@@ -59,10 +59,7 @@ library CurveFraxUsdcPoolHelper {
         return (total_supply * (D2 - D0)) / D0;
     }
 
-    function _get_D_mem(
-        uint256[N_COINS] memory balances,
-        uint256 _amp
-    ) internal pure returns (uint256) {
+    function _get_D_mem(uint256[N_COINS] memory balances, uint256 _amp) internal pure returns (uint256) {
         uint256[N_COINS] memory _xp;
         _xp[0] = (RATE_0 * balances[0]) / PRECISION;
         _xp[1] = (RATE_1 * balances[1]) / PRECISION;
@@ -116,10 +113,7 @@ library CurveFraxUsdcPoolHelper {
         }
     }
 
-    function _getTokenAmounts(
-        address token,
-        uint256 amount
-    ) internal pure returns (uint256[N_COINS] memory res) {
+    function _getTokenAmounts(address token, uint256 amount) internal pure returns (uint256[N_COINS] memory res) {
         res[token == FRAX ? 0 : 1] = amount;
     }
 }

package/contracts/core/StandardizedYield/implementations/Convex/base/CurveUsdd3CrvPoolHelper.sol

@@ -25,10 +25,7 @@ library CurveUsdd3CrvPoolHelper {
         balances[1] = ICrvPool(POOL).balances(1);
     }
 
-    function _getTokenAmounts(
-        address token,
-        uint256 amount
-    ) internal pure returns (uint256[N_COINS] memory res) {
+    function _getTokenAmounts(address token, uint256 amount) internal pure returns (uint256[N_COINS] memory res) {
         res[token == USDD ? 0 : 1] = amount;
     }
 
@@ -138,9 +135,7 @@ library CurveUsdd3CrvPoolHelper {
         assert(false);
     }
 
-    function arrayClone(
-        uint256[N_COINS] memory a
-    ) internal pure returns (uint256[N_COINS] memory res) {
+    function arrayClone(uint256[N_COINS] memory a) internal pure returns (uint256[N_COINS] memory res) {
         for (uint256 i = 0; i < N_COINS; ++i) {
             res[i] = a[i];
         }

package/contracts/core/StandardizedYield/implementations/Convex/base/PendleConvexLPSY.sol

@@ -35,9 +35,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         _safeApproveInf(crvLp, BOOSTER);
     }
 
-    function _getPoolInfo(
-        uint256 _cvxPid
-    ) internal view returns (address _crvLp, address _cvxRewardManager) {
+    function _getPoolInfo(uint256 _cvxPid) internal view returns (address _crvLp, address _cvxRewardManager) {
         if (_cvxPid > IBooster(BOOSTER).poolLength()) revert Errors.SYCurveInvalidPid();
 
         (_crvLp, , , _cvxRewardManager, , ) = IBooster(BOOSTER).poolInfo(_cvxPid);
@@ -51,10 +49,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
      * If any of the base pool tokens are deposited, it will first add liquidity to the curve pool and mint LP,
      * which will then be deposited into convex
      */
-    function _deposit(
-        address tokenIn,
-        uint256 amount
-    ) internal virtual override returns (uint256 amountSharesOut) {
+    function _deposit(address tokenIn, uint256 amount) internal virtual override returns (uint256 amountSharesOut) {
         if (tokenIn == crvLp) {
             amountSharesOut = amount;
         } else {
@@ -148,15 +143,9 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
 
     function isValidTokenOut(address token) public view virtual override returns (bool);
 
-    function _depositToCurve(
-        address tokenIn,
-        uint256 amountTokenToDeposit
-    ) internal virtual returns (uint256);
+    function _depositToCurve(address tokenIn, uint256 amountTokenToDeposit) internal virtual returns (uint256);
 
-    function _redeemFromCurve(
-        address tokenOut,
-        uint256 amountLpToRedeem
-    ) internal virtual returns (uint256);
+    function _redeemFromCurve(address tokenOut, uint256 amountLpToRedeem) internal virtual returns (uint256);
 
     function _previewDepositToCurve(
         address token,
@@ -168,11 +157,7 @@ abstract contract PendleConvexLPSY is SYBaseWithRewards {
         uint256 amountLpToRedeem
     ) internal view virtual returns (uint256 amountTokenOut);
 
-    function assetInfo()
-        external
-        view
-        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
-    {
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
         return (AssetType.LIQUIDITY, crvLp, IERC20Metadata(crvLp).decimals());
     }
 }