@pendle/core-v2 2.29.4 → 2.30.0

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWethWstethSYV2.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/IERC20.sol";
 import "./base/PendleAuraBalancerStableLPSYV2.sol";
@@ -16,14 +16,9 @@ contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper
         MetaStablePreview _previewHelper
     ) PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _previewHelper) StEthHelper() {}
 
-    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 == NATIVE) {
-            IWETH(WETH).deposit{ value: amount }();
+            IWETH(WETH).deposit{value: amount}();
             amountSharesOut = super._deposit(WETH, amount);
         } else if (tokenIn == STETH) {
             uint256 amountWstETH = _depositWstETH(STETH, amount);
@@ -50,13 +45,10 @@ contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper
         }
     }
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        virtual
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 amountSharesOut) {
         if (tokenIn == NATIVE) {
             amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
         } else if (tokenIn == STETH) {
@@ -67,13 +59,10 @@ contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        virtual
-        override
-        returns (uint256 amountTokenOut)
-    {
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
         if (tokenOut == NATIVE) {
             amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
         } else if (tokenOut == STETH) {
@@ -84,13 +73,7 @@ contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper
         }
     }
 
-    function _getPoolTokenAddresses()
-        internal
-        view
-        virtual
-        override
-        returns (address[] memory res)
-    {
+    function _getPoolTokenAddresses() internal view virtual override returns (address[] memory res) {
         res = new address[](2);
         res[0] = WSTETH;
         res[1] = WETH;
@@ -137,18 +120,10 @@ contract PendleAuraWethWstethSYV2 is PendleAuraBalancerStableLPSYV2, StEthHelper
     }
 
     function isValidTokenIn(address token) public view virtual override returns (bool) {
-        return (token == LP ||
-            token == WSTETH ||
-            token == WETH ||
-            token == STETH ||
-            token == NATIVE);
+        return (token == LP || token == WSTETH || token == WETH || token == STETH || token == NATIVE);
     }
 
     function isValidTokenOut(address token) public view virtual override returns (bool) {
-        return (token == LP ||
-            token == WSTETH ||
-            token == WETH ||
-            token == STETH ||
-            token == NATIVE);
+        return (token == LP || token == WSTETH || token == WETH || token == STETH || token == NATIVE);
     }
 }

package/contracts/core/StandardizedYield/implementations/BalancerStable/PendleAuraWstethAnkreth.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/PendleAuraBalancerStableLPSYV2.sol";
 import "./base/ComposableStable/ComposableStablePreview.sol";
@@ -18,17 +18,10 @@ contract PendleAuraWstethAnkreth is PendleAuraBalancerStableLPSYV2, StEthHelper
         string memory _symbol,
         ComposableStablePreview _composablePreviewHelper
     )
-        PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _composablePreviewHelper)
-    //solhint-disable-next-line
-    {
+        PendleAuraBalancerStableLPSYV2(_name, _symbol, LP, AURA_PID, _composablePreviewHelper) //solhint-disable-next-line
+    {}
 
-    }
-
-    function _deposit(address tokenIn, uint256 amount)
-        internal
-        override
-        returns (uint256 amountSharesOut)
-    {
+    function _deposit(address tokenIn, uint256 amount) internal override returns (uint256 amountSharesOut) {
         if (tokenIn == NATIVE || tokenIn == STETH) {
             uint256 amountWstETH = _depositWstETH(tokenIn, amount);
             amountSharesOut = super._deposit(WSTETH, amountWstETH);
@@ -50,12 +43,7 @@ contract PendleAuraWstethAnkreth is PendleAuraBalancerStableLPSYV2, StEthHelper
         }
     }
 
-    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit) internal view override returns (uint256) {
         if (tokenIn == NATIVE || tokenIn == STETH) {
             uint256 amountWstETH = _previewDepositWstETH(tokenIn, amountTokenToDeposit);
             return super._previewDeposit(WSTETH, amountWstETH);
@@ -64,12 +52,7 @@ contract PendleAuraWstethAnkreth is PendleAuraBalancerStableLPSYV2, StEthHelper
         }
     }
 
-    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
-        internal
-        view
-        override
-        returns (uint256)
-    {
+    function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem) internal view override returns (uint256) {
         if (tokenOut == STETH) {
             uint256 amountWstETH = super._previewRedeem(WSTETH, amountSharesToRedeem);
             return _previewRedeemWstETH(amountWstETH);
@@ -140,11 +123,7 @@ contract PendleAuraWstethAnkreth is PendleAuraBalancerStableLPSYV2, StEthHelper
     }
 
     function isValidTokenIn(address token) public pure override returns (bool) {
-        return (token == NATIVE ||
-            token == STETH ||
-            token == WSTETH ||
-            token == ANKRETH ||
-            token == LP);
+        return (token == NATIVE || token == STETH || token == WSTETH || token == ANKRETH || token == LP);
     }
 
     function isValidTokenOut(address token) public pure override returns (bool) {

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStableMath.sol

@@ -11,11 +11,10 @@ library ComposableStableMath {
     uint256 internal constant _MAX_AMP = 5000;
     uint256 internal constant _AMP_PRECISION = 1e3;
 
-    function _calculateInvariant(uint256 amplificationParameter, uint256[] memory balances)
-        internal
-        pure
-        returns (uint256)
-    {
+    function _calculateInvariant(
+        uint256 amplificationParameter,
+        uint256[] memory balances
+    ) internal pure returns (uint256) {
         unchecked {
             /**********************************************************************************************
         // invariant                                                                                 //
@@ -54,17 +53,14 @@ library ComposableStableMath {
                 invariant = divDown(
                     mul(
                         // (ampTimesTotal * sum) / AMP_PRECISION + D_P * numTokens
-                        (
-                            divDown(mul(ampTimesTotal, sum), _AMP_PRECISION).add(
-                                mul(D_P, numTokens)
-                            )
-                        ),
+                        (divDown(mul(ampTimesTotal, sum), _AMP_PRECISION).add(mul(D_P, numTokens))),
                         invariant
                     ),
                     // ((ampTimesTotal - _AMP_PRECISION) * invariant) / _AMP_PRECISION + (numTokens + 1) * D_P
                     (
-                        divDown(mul((ampTimesTotal - _AMP_PRECISION), invariant), _AMP_PRECISION)
-                            .add(mul((numTokens + 1), D_P))
+                        divDown(mul((ampTimesTotal - _AMP_PRECISION), invariant), _AMP_PRECISION).add(
+                            mul((numTokens + 1), D_P)
+                        )
                     )
                 );
 
@@ -106,9 +102,7 @@ library ComposableStableMath {
             for (uint256 i = 0; i < balances.length; i++) {
                 uint256 currentWeight = balances[i].divDown(sumBalances);
                 balanceRatiosWithFee[i] = balances[i].add(amountsIn[i]).divDown(balances[i]);
-                invariantRatioWithFees = invariantRatioWithFees.add(
-                    balanceRatiosWithFee[i].mulDown(currentWeight)
-                );
+                invariantRatioWithFees = invariantRatioWithFees.add(balanceRatiosWithFee[i].mulDown(currentWeight));
             }
 
             // Second loop calculates new amounts in, taking into account the fee on the percentage excess
@@ -118,9 +112,7 @@ library ComposableStableMath {
 
                 // Check if the balance ratio is greater than the ideal ratio to charge fees or not
                 if (balanceRatiosWithFee[i] > invariantRatioWithFees) {
-                    uint256 nonTaxableAmount = balances[i].mulDown(
-                        invariantRatioWithFees.sub(FixedPoint.ONE)
-                    );
+                    uint256 nonTaxableAmount = balances[i].mulDown(invariantRatioWithFees.sub(FixedPoint.ONE));
                     uint256 taxableAmount = amountsIn[i].sub(nonTaxableAmount);
                     // No need to use checked arithmetic for the swap fee, it is guaranteed to be lower than 50%
                     amountInWithoutFee = nonTaxableAmount.add(
@@ -157,9 +149,7 @@ library ComposableStableMath {
         unchecked {
             // Token out, so we round down overall.
 
-            uint256 newInvariant = bptTotalSupply.sub(bptAmountIn).divUp(bptTotalSupply).mulUp(
-                currentInvariant
-            );
+            uint256 newInvariant = bptTotalSupply.sub(bptAmountIn).divUp(bptTotalSupply).mulUp(currentInvariant);
 
             // Calculate amount out without fee
             uint256 newBalanceTokenIndex = _getTokenBalanceGivenInvariantAndAllOtherBalances(
@@ -215,10 +205,7 @@ library ComposableStableMath {
 
             uint256 inv2 = mul(invariant, invariant);
             // We remove the balance from c by multiplying it
-            uint256 c = mul(
-                mul(divUp(inv2, mul(ampTimesTotal, P_D)), _AMP_PRECISION),
-                balances[tokenIndex]
-            );
+            uint256 c = mul(mul(divUp(inv2, mul(ampTimesTotal, P_D)), _AMP_PRECISION), balances[tokenIndex]);
             uint256 b = sum.add(mul(divDown(invariant, ampTimesTotal), _AMP_PRECISION));
 
             // We iterate to find the balance
@@ -260,11 +247,7 @@ library ComposableStableMath {
         }
     }
 
-    function div(
-        uint256 a,
-        uint256 b,
-        bool roundUp
-    ) private pure returns (uint256) {
+    function div(uint256 a, uint256 b, bool roundUp) private pure returns (uint256) {
         return roundUp ? divUp(a, b) : divDown(a, b);
     }
 

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStablePreviewProxy.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/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStablePreviewV4.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/IERC20.sol";
 import "../../../../../../interfaces/Balancer/IComposableStable.sol";
@@ -145,17 +145,10 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
             uint256 preJoinExitInvariant
         ) = _beforeJoinExit(registeredBalances, imd, caches);
 
-        function(
-            uint256[] memory,
-            uint256,
-            uint256,
-            uint256,
-            uint256[] memory,
-            bytes memory,
-            ImmutableData memory
-        ) internal view returns (uint256, uint256[] memory) _doJoinOrExit = (
-                isJoin ? _doJoin : _doExit
-            );
+        function(uint256[] memory, uint256, uint256, uint256, uint256[] memory, bytes memory, ImmutableData memory)
+            internal
+            view
+            returns (uint256, uint256[] memory) _doJoinOrExit = (isJoin ? _doJoin : _doExit);
 
         (bptAmount, amountsDelta) = _doJoinOrExit(
             balances,
@@ -180,9 +173,7 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
     ) internal pure returns (uint256[] memory registeredTokenAmounts) {
         registeredTokenAmounts = new uint256[](amounts.length + 1);
         for (uint256 i = 0; i < registeredTokenAmounts.length; i++) {
-            registeredTokenAmounts[i] = i == imd.bptIndex
-                ? bptAmount
-                : amounts[i < imd.bptIndex ? i : i - 1];
+            registeredTokenAmounts[i] = i == imd.bptIndex ? bptAmount : amounts[i < imd.bptIndex ? i : i - 1];
         }
     }
 
@@ -237,20 +228,12 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         uint256 currentAmp,
         uint256 preJoinExitSupply,
         uint256 preJoinExitInvariant,
-        uint256[] memory, /*scalingFactors*/
+        uint256[] memory /*scalingFactors*/,
         bytes memory userData,
         ImmutableData memory imd
     ) internal view returns (uint256, uint256[] memory) {
         // this is always true given Pendle SY context
-        return
-            _exitExactBPTInForTokenOut(
-                preJoinExitSupply,
-                preJoinExitInvariant,
-                currentAmp,
-                balances,
-                userData,
-                imd
-            );
+        return _exitExactBPTInForTokenOut(preJoinExitSupply, preJoinExitInvariant, currentAmp, balances, userData, imd);
     }
 
     function _exitExactBPTInForTokenOut(
@@ -281,30 +264,14 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         uint256[] memory registeredBalances,
         ImmutableData memory imd,
         TokenRateCache[] memory caches
-    )
-        internal
-        view
-        returns (
-            uint256,
-            uint256[] memory,
-            uint256,
-            uint256
-        )
-    {
-        (uint256 lastJoinExitAmp, uint256 lastPostJoinExitInvariant) = IComposableStable(imd.LP)
-            .getLastJoinExitData();
+    ) internal view returns (uint256, uint256[] memory, uint256, uint256) {
+        (uint256 lastJoinExitAmp, uint256 lastPostJoinExitInvariant) = IComposableStable(imd.LP).getLastJoinExitData();
 
         (
             uint256 preJoinExitSupply,
             uint256[] memory balances,
             uint256 oldAmpPreJoinExitInvariant
-        ) = _payProtocolFeesBeforeJoinExit(
-                registeredBalances,
-                lastJoinExitAmp,
-                lastPostJoinExitInvariant,
-                imd,
-                caches
-            );
+        ) = _payProtocolFeesBeforeJoinExit(registeredBalances, lastJoinExitAmp, lastPostJoinExitInvariant, imd, caches);
 
         (uint256 currentAmp, , ) = IComposableStable(imd.LP).getAmplificationParameter();
         uint256 preJoinExitInvariant = currentAmp == lastJoinExitAmp
@@ -320,30 +287,13 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         uint256 lastPostJoinExitInvariant,
         ImmutableData memory imd,
         TokenRateCache[] memory caches
-    )
-        internal
-        view
-        returns (
-            uint256,
-            uint256[] memory,
-            uint256
-        )
-    {
-        (uint256 virtualSupply, uint256[] memory balances) = _dropBptItemFromBalances(
-            imd,
-            registeredBalances
-        );
+    ) internal view returns (uint256, uint256[] memory, uint256) {
+        (uint256 virtualSupply, uint256[] memory balances) = _dropBptItemFromBalances(imd, registeredBalances);
 
         (
             uint256 expectedProtocolOwnershipPercentage,
             uint256 currentInvariantWithLastJoinExitAmp
-        ) = _getProtocolPoolOwnershipPercentage(
-                balances,
-                lastJoinExitAmp,
-                lastPostJoinExitInvariant,
-                imd,
-                caches
-            );
+        ) = _getProtocolPoolOwnershipPercentage(balances, lastJoinExitAmp, lastPostJoinExitInvariant, imd, caches);
 
         uint256 protocolFeeAmount = _calculateAdjustedProtocolFeeAmount(
             virtualSupply,
@@ -371,22 +321,17 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         uint256 swapFeeGrowthInvariantDelta = (swapFeeGrowthInvariant > lastPostJoinExitInvariant)
             ? swapFeeGrowthInvariant - lastPostJoinExitInvariant
             : 0;
-        uint256 nonExemptYieldGrowthInvariantDelta = (totalNonExemptGrowthInvariant >
-            swapFeeGrowthInvariant)
+        uint256 nonExemptYieldGrowthInvariantDelta = (totalNonExemptGrowthInvariant > swapFeeGrowthInvariant)
             ? totalNonExemptGrowthInvariant - swapFeeGrowthInvariant
             : 0;
 
-        uint256 protocolSwapFeePercentage = swapFeeGrowthInvariantDelta
-            .divDown(totalGrowthInvariant)
-            .mulDown(
-                IComposableStable(imd.LP).getProtocolFeePercentageCache(0) // ProtocolFeeType.SWAP // can't get better
-            );
+        uint256 protocolSwapFeePercentage = swapFeeGrowthInvariantDelta.divDown(totalGrowthInvariant).mulDown(
+            IComposableStable(imd.LP).getProtocolFeePercentageCache(0) // ProtocolFeeType.SWAP // can't get better
+        );
 
-        uint256 protocolYieldPercentage = nonExemptYieldGrowthInvariantDelta
-            .divDown(totalGrowthInvariant)
-            .mulDown(
-                IComposableStable(imd.LP).getProtocolFeePercentageCache(2) // ProtocolFeeType.YIELD // can't get better
-            );
+        uint256 protocolYieldPercentage = nonExemptYieldGrowthInvariantDelta.divDown(totalGrowthInvariant).mulDown(
+            IComposableStable(imd.LP).getProtocolFeePercentageCache(2) // ProtocolFeeType.YIELD // can't get better
+        );
 
         // These percentages can then be simply added to compute the total protocol Pool ownership percentage.
         // This is naturally bounded above by FixedPoint.ONE so this addition cannot overflow.
@@ -401,15 +346,9 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
     )
         internal
         pure
-        returns (
-            uint256 swapFeeGrowthInvariant,
-            uint256 totalNonExemptGrowthInvariant,
-            uint256 totalGrowthInvariant
-        )
+        returns (uint256 swapFeeGrowthInvariant, uint256 totalNonExemptGrowthInvariant, uint256 totalGrowthInvariant)
     {
-        swapFeeGrowthInvariant = lastJoinExitAmp._calculateInvariant(
-            _getAdjustedBalances(balances, true, imd, caches)
-        );
+        swapFeeGrowthInvariant = lastJoinExitAmp._calculateInvariant(_getAdjustedBalances(balances, true, imd, caches));
 
         if (imd.noTokensExempt) {
             totalNonExemptGrowthInvariant = lastJoinExitAmp._calculateInvariant(balances);
@@ -446,19 +385,14 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         return adjustedBalances;
     }
 
-    function _adjustedBalance(uint256 balance, TokenRateCache memory cache)
-        private
-        pure
-        returns (uint256)
-    {
+    function _adjustedBalance(uint256 balance, TokenRateCache memory cache) private pure returns (uint256) {
         return (balance * cache.oldRate) / cache.currentRate;
     }
 
-    function _calculateAdjustedProtocolFeeAmount(uint256 supply, uint256 basePercentage)
-        internal
-        pure
-        returns (uint256)
-    {
+    function _calculateAdjustedProtocolFeeAmount(
+        uint256 supply,
+        uint256 basePercentage
+    ) internal pure returns (uint256) {
         return supply.mulDown(basePercentage).divDown(basePercentage.complement());
     }
 
@@ -466,17 +400,10 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         ImmutableData memory imd,
         uint256[] memory registeredBalances
     ) internal view returns (uint256, uint256[] memory) {
-        return (
-            _getVirtualSupply(imd, registeredBalances[imd.bptIndex]),
-            _dropBptItem(imd, registeredBalances)
-        );
+        return (_getVirtualSupply(imd, registeredBalances[imd.bptIndex]), _dropBptItem(imd, registeredBalances));
     }
 
-    function _dropBptItem(ImmutableData memory imd, uint256[] memory amounts)
-        internal
-        pure
-        returns (uint256[] memory)
-    {
+    function _dropBptItem(ImmutableData memory imd, uint256[] memory amounts) internal pure returns (uint256[] memory) {
         uint256[] memory amountsWithoutBpt = new uint256[](amounts.length - 1);
         for (uint256 i = 0; i < amountsWithoutBpt.length; i++) {
             amountsWithoutBpt[i] = amounts[i < imd.bptIndex ? i : i + 1];
@@ -485,27 +412,19 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         return amountsWithoutBpt;
     }
 
-    function _getVirtualSupply(ImmutableData memory imd, uint256 bptBalance)
-        internal
-        view
-        returns (uint256)
-    {
+    function _getVirtualSupply(ImmutableData memory imd, uint256 bptBalance) internal view returns (uint256) {
         return (IERC20(imd.LP).totalSupply()).sub(bptBalance); // can't get better
     }
 
-    function _beforeSwapJoinExit(ImmutableData memory imd)
-        internal
-        view
-        returns (TokenRateCache[] memory tokenRateCaches)
-    {
+    function _beforeSwapJoinExit(
+        ImmutableData memory imd
+    ) internal view returns (TokenRateCache[] memory tokenRateCaches) {
         return _cacheTokenRatesIfNecessary(imd);
     }
 
-    function _cacheTokenRatesIfNecessary(ImmutableData memory imd)
-        internal
-        view
-        returns (TokenRateCache[] memory tokenRateCaches)
-    {
+    function _cacheTokenRatesIfNecessary(
+        ImmutableData memory imd
+    ) internal view returns (TokenRateCache[] memory tokenRateCaches) {
         tokenRateCaches = new TokenRateCache[](imd.totalTokens);
 
         for (uint256 i = 0; i < imd.totalTokens; ++i) {
@@ -516,11 +435,10 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
     /**
      * @dev Caches the rate for a token if necessary. It ignores the call if there is no provider set.
      */
-    function _cacheTokenRateIfNecessary(uint256 index, ImmutableData memory imd)
-        internal
-        view
-        returns (TokenRateCache memory res)
-    {
+    function _cacheTokenRateIfNecessary(
+        uint256 index,
+        ImmutableData memory imd
+    ) internal view returns (TokenRateCache memory res) {
         if (index == imd.bptIndex || !_hasRateProvider(imd, index)) return res;
 
         uint256 expires;
@@ -533,12 +451,10 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         }
     }
 
-    function _scalingFactors(ImmutableData memory imd, TokenRateCache[] memory caches)
-        internal
-        view
-        virtual
-        returns (uint256[] memory)
-    {
+    function _scalingFactors(
+        ImmutableData memory imd,
+        TokenRateCache[] memory caches
+    ) internal view virtual returns (uint256[] memory) {
         // There is no need to check the arrays length since both are based on `_getTotalTokens`
         uint256[] memory scalingFactors = new uint256[](imd.totalTokens);
 
@@ -549,12 +465,7 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
         return scalingFactors;
     }
 
-    function _getTokenRate(TokenRateCache[] memory caches, uint256 index)
-        internal
-        view
-        virtual
-        returns (uint256)
-    {
+    function _getTokenRate(TokenRateCache[] memory caches, uint256 index) internal view virtual returns (uint256) {
         return caches[index].currentRate == 0 ? FixedPoint.ONE : caches[index].currentRate;
     }
 
@@ -562,39 +473,25 @@ contract ComposableStablePreviewV4 is ComposableStablePreview {
                                Helpers functions
     //////////////////////////////////////////////////////////////*/
 
-    function _upscaleArray(uint256[] memory amounts, uint256[] memory scalingFactors)
-        internal
-        pure
-    {
+    function _upscaleArray(uint256[] memory amounts, uint256[] memory scalingFactors) internal pure {
         uint256 length = amounts.length;
         for (uint256 i = 0; i < length; ++i) {
             amounts[i] = FixedPoint.mulDown(amounts[i], scalingFactors[i]);
         }
     }
 
-    function _downscaleDownArray(uint256[] memory amounts, uint256[] memory scalingFactors)
-        internal
-        pure
-    {
+    function _downscaleDownArray(uint256[] memory amounts, uint256[] memory scalingFactors) internal pure {
         uint256 length = amounts.length;
         for (uint256 i = 0; i < length; ++i) {
             amounts[i] = FixedPoint.divDown(amounts[i], scalingFactors[i]);
         }
     }
 
-    function _hasRateProvider(ImmutableData memory imd, uint256 index)
-        internal
-        pure
-        returns (bool)
-    {
+    function _hasRateProvider(ImmutableData memory imd, uint256 index) internal pure returns (bool) {
         return address(imd.rateProviders[index]) != address(0);
     }
 
-    function _isTokenExemptFromYieldProtocolFee(ImmutableData memory imd, uint256 index)
-        internal
-        pure
-        returns (bool)
-    {
+    function _isTokenExemptFromYieldProtocolFee(ImmutableData memory imd, uint256 index) internal pure returns (bool) {
         return imd.isExemptFromYieldProtocolFee[index];
     }
 }