@pendle/core-v2 2.29.3 → 2.30.0

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStablePreviewV5.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 ComposableStablePreviewV5 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 ComposableStablePreviewV5 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 ComposableStablePreviewV5 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 ComposableStablePreviewV5 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 ComposableStablePreviewV5 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,
@@ -366,33 +316,22 @@ contract ComposableStablePreviewV5 is ComposableStablePreview {
             uint256 swapFeeGrowthInvariant,
             uint256 totalNonExemptGrowthInvariant,
             uint256 totalGrowthInvariant
-        ) = _getGrowthInvariants(
-                balances,
-                lastJoinExitAmp,
-                lastPostJoinExitInvariant,
-                imd,
-                caches
-            );
+        ) = _getGrowthInvariants(balances, lastJoinExitAmp, lastPostJoinExitInvariant, imd, caches);
 
         if (totalGrowthInvariant <= lastPostJoinExitInvariant) {
             return (0, totalGrowthInvariant);
         }
 
         uint256 swapFeeGrowthInvariantDelta = swapFeeGrowthInvariant - lastPostJoinExitInvariant;
-        uint256 nonExemptYieldGrowthInvariantDelta = totalNonExemptGrowthInvariant -
-            swapFeeGrowthInvariant;
+        uint256 nonExemptYieldGrowthInvariantDelta = totalNonExemptGrowthInvariant - swapFeeGrowthInvariant;
 
-        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.
@@ -408,11 +347,7 @@ contract ComposableStablePreviewV5 is ComposableStablePreview {
     )
         internal
         pure
-        returns (
-            uint256 swapFeeGrowthInvariant,
-            uint256 totalNonExemptGrowthInvariant,
-            uint256 totalGrowthInvariant
-        )
+        returns (uint256 swapFeeGrowthInvariant, uint256 totalNonExemptGrowthInvariant, uint256 totalGrowthInvariant)
     {
         // Total growth invariant is always calculated with the current (scaled / unadjusted) balances.
         totalGrowthInvariant = lastJoinExitAmp._calculateInvariant(balances);
@@ -467,19 +402,14 @@ contract ComposableStablePreviewV5 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());
     }
 
@@ -487,17 +417,10 @@ contract ComposableStablePreviewV5 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];
@@ -506,27 +429,19 @@ contract ComposableStablePreviewV5 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) {
@@ -537,11 +452,10 @@ contract ComposableStablePreviewV5 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;
@@ -554,12 +468,10 @@ contract ComposableStablePreviewV5 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);
 
@@ -570,12 +482,7 @@ contract ComposableStablePreviewV5 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;
     }
 
@@ -583,39 +490,25 @@ contract ComposableStablePreviewV5 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];
     }
 }

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/BbAPoolHelper.sol

@@ -27,7 +27,7 @@ abstract contract BbAPoolHelper is TokenHelper {
         uint256 amountIn
     ) internal returns (uint256 amountOut) {
         return
-            IVault(BALANCER_VAULT).swap{ value: (tokenIn == NATIVE ? amountIn : 0) }(
+            IVault(BALANCER_VAULT).swap{value: (tokenIn == NATIVE ? amountIn : 0)}(
                 IVault.SingleSwap({
                     poolId: poolId,
                     kind: IVault.SwapKind.GIVEN_IN,
@@ -68,10 +68,7 @@ abstract contract BbAWethHelper is BbAPoolHelper {
         _safeApproveInfVault(WA_WETH);
     }
 
-    function _depositBbAWeth(
-        address tokenIn,
-        uint256 amountDep
-    ) internal virtual returns (uint256 amountOut) {
+    function _depositBbAWeth(address tokenIn, uint256 amountDep) internal virtual returns (uint256 amountOut) {
         amountOut = joinExitPool(address(this), BB_A_WETH_POOL_ID, tokenIn, BB_A_WETH, amountDep);
     }
 
@@ -80,13 +77,7 @@ abstract contract BbAWethHelper is BbAPoolHelper {
         address tokenOut,
         uint256 amountRedeem
     ) internal virtual returns (uint256 amountTokenOut) {
-        amountTokenOut = joinExitPool(
-            receiver,
-            BB_A_WETH_POOL_ID,
-            BB_A_WETH,
-            tokenOut,
-            amountRedeem
-        );
+        amountTokenOut = joinExitPool(receiver, BB_A_WETH_POOL_ID, BB_A_WETH, tokenOut, amountRedeem);
     }
 
     function _previewDepositBbAWeth(
@@ -102,10 +93,7 @@ abstract contract BbAWethHelper is BbAPoolHelper {
             );
     }
 
-    function _previewRedeemBbAWeth(
-        address tokenOut,
-        uint256 amountRedeem
-    ) internal view returns (uint256 amountOut) {
+    function _previewRedeemBbAWeth(address tokenOut, uint256 amountRedeem) internal view returns (uint256 amountOut) {
         return
             linearPreviewHelper.joinExitPoolPreview(
                 BB_A_WETH_POOL_ID,

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/LinearMath.sol

@@ -234,9 +234,7 @@ library LinearMath {
         uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
 
         uint256 newBptBalance = bptSupply.add(bptOut);
-        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(
-            nominalMain
-        );
+        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(nominalMain);
 
         return newWrappedBalance.sub(wrappedBalance);
     }
@@ -254,18 +252,12 @@ library LinearMath {
         uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
 
         uint256 newBptBalance = bptSupply.sub(bptIn);
-        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(
-            nominalMain
-        );
+        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(nominalMain);
 
         return wrappedBalance.sub(newWrappedBalance);
     }
 
-    function _calcInvariant(uint256 nominalMainBalance, uint256 wrappedBalance)
-        internal
-        pure
-        returns (uint256)
-    {
+    function _calcInvariant(uint256 nominalMainBalance, uint256 wrappedBalance) internal pure returns (uint256) {
         return nominalMainBalance.add(wrappedBalance);
     }
 
@@ -291,18 +283,11 @@ library LinearMath {
             // Since real = nominal + fees, rounding down fees is equivalent to rounding down real.
 
             if (nominal < params.lowerTarget) {
-                return
-                    (nominal.add(params.fee.mulDown(params.lowerTarget))).divDown(
-                        FixedPoint.ONE.add(params.fee)
-                    );
+                return (nominal.add(params.fee.mulDown(params.lowerTarget))).divDown(FixedPoint.ONE.add(params.fee));
             } else if (nominal <= params.upperTarget) {
                 return nominal;
             } else {
-                return (
-                    nominal.sub(params.fee.mulDown(params.upperTarget)).divDown(
-                        FixedPoint.ONE.sub(params.fee)
-                    )
-                );
+                return (nominal.sub(params.fee.mulDown(params.upperTarget)).divDown(FixedPoint.ONE.sub(params.fee)));
             }
         }
     }
@@ -352,11 +337,7 @@ library LinearMath {
         }
     }
 
-    function div(
-        uint256 a,
-        uint256 b,
-        bool roundUp
-    ) internal pure returns (uint256) {
+    function div(uint256 a, uint256 b, bool roundUp) internal pure returns (uint256) {
         return roundUp ? divUp(a, b) : divDown(a, b);
     }
 

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/LinearPreview.sol

@@ -30,11 +30,12 @@ contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    function joinExitPoolPreview(bytes32 poolId, address tokenIn, address tokenOut, uint256 amountIn)
-        external
-        view
-        returns (uint256 amountOut)
-    {
+    function joinExitPoolPreview(
+        bytes32 poolId,
+        address tokenIn,
+        address tokenOut,
+        uint256 amountIn
+    ) external view returns (uint256 amountOut) {
         IVault.SwapRequest memory request = IVault.SwapRequest({
             kind: IVault.SwapKind.GIVEN_IN,
             tokenIn: IERC20(tokenIn),
@@ -48,7 +49,7 @@ contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
             userData: EMPTY_BYTES
         });
 
-        (IERC20[] memory tokens, uint256[] memory balances,) = IVault(BALANCER_VAULT).getPoolTokens(poolId);
+        (IERC20[] memory tokens, uint256[] memory balances, ) = IVault(BALANCER_VAULT).getPoolTokens(poolId);
         address pool = address(uint160(uint256(poolId) >> (12 * 8)));
         IERC20 mainToken = IERC20(IERC4626LinearPool(pool).getMainToken());
 
@@ -56,7 +57,7 @@ contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
         uint256 indexOut;
         ImmutableData memory imd;
 
-        for (uint256 i = 0; i < tokens.length;) {
+        for (uint256 i = 0; i < tokens.length; ) {
             if (tokens[i] == mainToken) {
                 imd._mainToken = mainToken;
                 imd._mainIndex = i;
@@ -135,15 +136,14 @@ contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
         //     request.tokenOut == _mainToken || request.tokenOut == _wrappedToken,
         //     Errors.INVALID_TOKEN
         // );
-        return (
-            request.tokenOut == imd._mainToken ? LinearMath._calcMainOutPerBptIn : LinearMath._calcWrappedOutPerBptIn
-        )(
-            request.amount,
-            balances[imd._mainIndex],
-            balances[imd._wrappedIndex],
-            _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
-            params
-        );
+        return
+            (request.tokenOut == imd._mainToken ? LinearMath._calcMainOutPerBptIn : LinearMath._calcWrappedOutPerBptIn)(
+                request.amount,
+                balances[imd._mainIndex],
+                balances[imd._wrappedIndex],
+                _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
+                params
+            );
     }
 
     function _swapGivenMainIn(
@@ -156,15 +156,16 @@ contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
         //     request.tokenOut == _wrappedToken || request.tokenOut == this,
         //     Errors.INVALID_TOKEN
         // );
-        return request.tokenOut == IERC20(imd.pool)
-            ? LinearMath._calcBptOutPerMainIn(
-                request.amount,
-                balances[imd._mainIndex],
-                balances[imd._wrappedIndex],
-                _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
-                params
-            )
-            : LinearMath._calcWrappedOutPerMainIn(request.amount, balances[imd._mainIndex], params);
+        return
+            request.tokenOut == IERC20(imd.pool)
+                ? LinearMath._calcBptOutPerMainIn(
+                    request.amount,
+                    balances[imd._mainIndex],
+                    balances[imd._wrappedIndex],
+                    _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
+                    params
+                )
+                : LinearMath._calcWrappedOutPerMainIn(request.amount, balances[imd._mainIndex], params);
     }
 
     function _swapGivenWrappedIn(
@@ -174,15 +175,16 @@ contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
         ImmutableData memory imd
     ) internal view returns (uint256) {
         // _require(request.tokenOut == _mainToken || request.tokenOut == this, Errors.INVALID_TOKEN);
-        return request.tokenOut == IERC20(imd.pool)
-            ? LinearMath._calcBptOutPerWrappedIn(
-                request.amount,
-                balances[imd._mainIndex],
-                balances[imd._wrappedIndex],
-                _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
-                params
-            )
-            : LinearMath._calcMainOutPerWrappedIn(request.amount, balances[imd._mainIndex], params);
+        return
+            request.tokenOut == IERC20(imd.pool)
+                ? LinearMath._calcBptOutPerWrappedIn(
+                    request.amount,
+                    balances[imd._mainIndex],
+                    balances[imd._wrappedIndex],
+                    _getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
+                    params
+                )
+                : LinearMath._calcMainOutPerWrappedIn(request.amount, balances[imd._mainIndex], params);
     }
 
     function _getVirtualSupply(uint256 bptBalance, address pool) internal view returns (uint256) {

package/contracts/core/StandardizedYield/implementations/BalancerStable/base/MetaStable/MetaStableMath.sol

@@ -94,9 +94,7 @@ library MetaStableMath {
             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
@@ -106,9 +104,7 @@ library MetaStableMath {
 
                 // 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(
@@ -148,9 +144,7 @@ library MetaStableMath {
 
             // Get the current and new invariants. Since we need a bigger new invariant, we round the current one up.
             uint256 currentInvariant = _calculateInvariant(amp, balances, true);
-            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(
@@ -248,10 +242,7 @@ library MetaStableMath {
 
             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