@pendle/core-v2 2.15.2 → 2.16.0

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

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../../libraries/TokenHelper.sol";
+import "../../../../../../interfaces/Balancer/IVault.sol";
+import "./LinearPreview.sol";
+
+abstract contract BbAPoolHelper is TokenHelper {
+    address private constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+    bytes private constant EMPTY_BYTES = abi.encode();
+
+    LinearPreview public immutable linearPreviewHelper;
+
+    constructor(LinearPreview _linearPreviewHelper) {
+        linearPreviewHelper = _linearPreviewHelper;
+    }
+
+    function _safeApproveInfVault(address token) internal {
+        _safeApproveInf(token, BALANCER_VAULT);
+    }
+
+    function joinExitPool(
+        address receiver,
+        bytes32 poolId,
+        address tokenIn,
+        address tokenOut,
+        uint256 amountIn
+    ) internal returns (uint256 amountOut) {
+        return
+            IVault(BALANCER_VAULT).swap{ value: (tokenIn == NATIVE ? amountIn : 0) }(
+                IVault.SingleSwap({
+                    poolId: poolId,
+                    kind: IVault.SwapKind.GIVEN_IN,
+                    assetIn: IAsset(tokenIn),
+                    assetOut: IAsset(tokenOut),
+                    amount: amountIn,
+                    userData: EMPTY_BYTES
+                }),
+                IVault.FundManagement({
+                    sender: address(this),
+                    fromInternalBalance: false,
+                    recipient: payable(receiver),
+                    toInternalBalance: false
+                }),
+                0,
+                block.timestamp
+            );
+    }
+}
+
+abstract contract BbAWethHelper is BbAPoolHelper {
+    address internal constant BB_A_WETH = 0x60D604890feaa0b5460B28A424407c24fe89374a;
+    address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+    address internal constant WA_WETH = 0x59463BB67dDD04fe58ED291ba36C26d99A39fbc6;
+    bytes32 internal constant BB_A_WETH_POOL_ID =
+        bytes32(0x60d604890feaa0b5460b28a424407c24fe89374a0000000000000000000004fc);
+
+    constructor(LinearPreview _linearPreviewHelper) BbAPoolHelper(_linearPreviewHelper) {
+        _safeApproveInfVault(WETH);
+        _safeApproveInfVault(WA_WETH);
+    }
+
+    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);
+    }
+
+    function _redeemBbAWeth(
+        address receiver,
+        address tokenOut,
+        uint256 amountRedeem
+    ) internal virtual returns (uint256 amountTokenOut) {
+        amountTokenOut = joinExitPool(
+            receiver,
+            BB_A_WETH_POOL_ID,
+            BB_A_WETH,
+            tokenOut,
+            amountRedeem
+        );
+    }
+
+    function _previewDepositBbAWeth(address tokenIn, uint256 amountDep)
+        internal
+        view
+        virtual
+        returns (uint256 amountOut)
+    {
+        return
+            linearPreviewHelper.joinExitPoolPreview(
+                BB_A_WETH_POOL_ID,
+                tokenIn == NATIVE ? WETH : tokenIn,
+                BB_A_WETH,
+                amountDep
+            );
+    }
+
+    function _previewRedeemBbAWeth(address tokenOut, uint256 amountRedeem)
+        internal
+        view
+        returns (uint256 amountOut)
+    {
+        return
+            linearPreviewHelper.joinExitPoolPreview(
+                BB_A_WETH_POOL_ID,
+                BB_A_WETH,
+                tokenOut == NATIVE ? WETH : tokenOut,
+                amountRedeem
+            );
+    }
+}

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

@@ -0,0 +1,381 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+import "../FixedPoint.sol";
+
+// These functions start with an underscore, as if they were part of a contract and not a library. At some point this
+// should be fixed.
+// solhint-disable private-vars-leading-underscore
+
+library LinearMath {
+    using FixedPoint for uint256;
+
+    // A thorough derivation of the formulas and derivations found here exceeds the scope of this file, so only
+    // introductory notions will be presented.
+
+    // A Linear Pool holds three tokens: the main token, the wrapped token, and the Pool share token (BPT). It is
+    // possible to exchange any of these tokens for any of the other two (so we have three trading pairs) in both
+    // directions (the first token of each pair can be bought or sold for the second) and by specifying either the input
+    // or output amount (typically referred to as 'given in' or 'given out'). A full description thus requires
+    // 3*2*2 = 12 functions.
+    // Wrapped tokens have a known, trusted exchange rate to main tokens. All functions here assume such a rate has
+    // already been applied, meaning main and wrapped balances can be compared as they are both expressed in the same
+    // units (those of main token).
+    // Additionally, Linear Pools feature a lower and upper target that represent the desired range of values for the
+    // main token balance. Any action that moves the main balance away from this range is charged a proportional fee,
+    // and any action that moves it towards this range is incentivized by paying the actor using these collected fees.
+    // The collected fees are not stored in a separate data structure: they are a function of the current main balance,
+    // targets and fee percentage. The main balance sans fees is known as the 'nominal balance', which is always smaller
+    // than the real balance except when the real balance is within the targets.
+    // The rule under which Linear Pools conduct trades between main and wrapped tokens is by keeping the sum of nominal
+    // main balance and wrapped balance constant: this value is known as the 'invariant'. BPT is backed by nominal
+    // reserves, meaning its supply is proportional to the invariant. As the wrapped token appreciates in value and its
+    // exchange rate to the main token increases, so does the invariant and thus the value of BPT (in main token units).
+
+    struct Params {
+        uint256 fee;
+        uint256 lowerTarget;
+        uint256 upperTarget;
+    }
+
+    function _calcBptOutPerMainIn(
+        uint256 mainIn,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount out, so we round down overall.
+
+        if (bptSupply == 0) {
+            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
+            // BPT supply is initialized to equal the invariant (which in this case is just the nominal main balance as
+            // there is no wrapped balance).
+            return _toNominal(mainIn, params);
+        }
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 afterNominalMain = _toNominal(mainBalance.add(mainIn), params);
+        uint256 deltaNominalMain = afterNominalMain.sub(previousNominalMain);
+        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+        return divDown(mul(bptSupply, deltaNominalMain), invariant);
+    }
+
+    function _calcBptInPerMainOut(
+        uint256 mainOut,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount in, so we round up overall.
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 afterNominalMain = _toNominal(mainBalance.sub(mainOut), params);
+        uint256 deltaNominalMain = previousNominalMain.sub(afterNominalMain);
+        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+        return divUp(mul(bptSupply, deltaNominalMain), invariant);
+    }
+
+    function _calcWrappedOutPerMainIn(
+        uint256 mainIn,
+        uint256 mainBalance,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount out, so we round down overall.
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 afterNominalMain = _toNominal(mainBalance.add(mainIn), params);
+        return afterNominalMain.sub(previousNominalMain);
+    }
+
+    function _calcWrappedInPerMainOut(
+        uint256 mainOut,
+        uint256 mainBalance,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount in, so we round up overall.
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 afterNominalMain = _toNominal(mainBalance.sub(mainOut), params);
+        return previousNominalMain.sub(afterNominalMain);
+    }
+
+    function _calcMainInPerBptOut(
+        uint256 bptOut,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount in, so we round up overall.
+
+        if (bptSupply == 0) {
+            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
+            // BPT supply is initialized to equal the invariant (which in this case is just the nominal main balance as
+            // there is no wrapped balance).
+            return _fromNominal(bptOut, params);
+        }
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+        uint256 deltaNominalMain = divUp(mul(invariant, bptOut), bptSupply);
+        uint256 afterNominalMain = previousNominalMain.add(deltaNominalMain);
+        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
+        return newMainBalance.sub(mainBalance);
+    }
+
+    function _calcMainOutPerBptIn(
+        uint256 bptIn,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount out, so we round down overall.
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
+        uint256 deltaNominalMain = divDown(mul(invariant, bptIn), bptSupply);
+        uint256 afterNominalMain = previousNominalMain.sub(deltaNominalMain);
+        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
+        return mainBalance.sub(newMainBalance);
+    }
+
+    function _calcMainOutPerWrappedIn(
+        uint256 wrappedIn,
+        uint256 mainBalance,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount out, so we round down overall.
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 afterNominalMain = previousNominalMain.sub(wrappedIn);
+        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
+        return mainBalance.sub(newMainBalance);
+    }
+
+    function _calcMainInPerWrappedOut(
+        uint256 wrappedOut,
+        uint256 mainBalance,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount in, so we round up overall.
+
+        uint256 previousNominalMain = _toNominal(mainBalance, params);
+        uint256 afterNominalMain = previousNominalMain.add(wrappedOut);
+        uint256 newMainBalance = _fromNominal(afterNominalMain, params);
+        return newMainBalance.sub(mainBalance);
+    }
+
+    function _calcBptOutPerWrappedIn(
+        uint256 wrappedIn,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount out, so we round down overall.
+
+        if (bptSupply == 0) {
+            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
+            // BPT supply is initialized to equal the invariant (which in this case is just the wrapped balance as
+            // there is no main balance).
+            return wrappedIn;
+        }
+
+        uint256 nominalMain = _toNominal(mainBalance, params);
+        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+
+        uint256 newWrappedBalance = wrappedBalance.add(wrappedIn);
+        uint256 newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
+
+        uint256 newBptBalance = divDown(mul(bptSupply, newInvariant), previousInvariant);
+
+        return newBptBalance.sub(bptSupply);
+    }
+
+    function _calcBptInPerWrappedOut(
+        uint256 wrappedOut,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount in, so we round up overall.
+
+        uint256 nominalMain = _toNominal(mainBalance, params);
+        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+
+        uint256 newWrappedBalance = wrappedBalance.sub(wrappedOut);
+        uint256 newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
+
+        uint256 newBptBalance = divDown(mul(bptSupply, newInvariant), previousInvariant);
+
+        return bptSupply.sub(newBptBalance);
+    }
+
+    function _calcWrappedInPerBptOut(
+        uint256 bptOut,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount in, so we round up overall.
+
+        if (bptSupply == 0) {
+            // BPT typically grows in the same ratio the invariant does. The first time liquidity is added however, the
+            // BPT supply is initialized to equal the invariant (which in this case is just the wrapped balance as
+            // there is no main balance).
+            return bptOut;
+        }
+
+        uint256 nominalMain = _toNominal(mainBalance, params);
+        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+
+        uint256 newBptBalance = bptSupply.add(bptOut);
+        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(
+            nominalMain
+        );
+
+        return newWrappedBalance.sub(wrappedBalance);
+    }
+
+    function _calcWrappedOutPerBptIn(
+        uint256 bptIn,
+        uint256 mainBalance,
+        uint256 wrappedBalance,
+        uint256 bptSupply,
+        Params memory params
+    ) internal pure returns (uint256) {
+        // Amount out, so we round down overall.
+
+        uint256 nominalMain = _toNominal(mainBalance, params);
+        uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
+
+        uint256 newBptBalance = bptSupply.sub(bptIn);
+        uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(
+            nominalMain
+        );
+
+        return wrappedBalance.sub(newWrappedBalance);
+    }
+
+    function _calcInvariant(uint256 nominalMainBalance, uint256 wrappedBalance)
+        internal
+        pure
+        returns (uint256)
+    {
+        return nominalMainBalance.add(wrappedBalance);
+    }
+
+    function _toNominal(uint256 real, Params memory params) internal pure returns (uint256) {
+        unchecked {
+            // Fees are always rounded down: either direction would work but we need to be consistent, and rounding down
+            // uses less gas.
+
+            if (real < params.lowerTarget) {
+                uint256 fees = (params.lowerTarget - real).mulDown(params.fee);
+                return real.sub(fees);
+            } else if (real <= params.upperTarget) {
+                return real;
+            } else {
+                uint256 fees = (real - params.upperTarget).mulDown(params.fee);
+                return real.sub(fees);
+            }
+        }
+    }
+
+    function _fromNominal(uint256 nominal, Params memory params) internal pure returns (uint256) {
+        unchecked {
+            // 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)
+                    );
+            } else if (nominal <= params.upperTarget) {
+                return nominal;
+            } else {
+                return (
+                    nominal.sub(params.fee.mulDown(params.upperTarget)).divDown(
+                        FixedPoint.ONE.sub(params.fee)
+                    )
+                );
+            }
+        }
+    }
+
+    function _calcTokensOutGivenExactBptIn(
+        uint256[] memory balances,
+        uint256 bptAmountIn,
+        uint256 bptTotalSupply,
+        uint256 bptIndex
+    ) internal pure returns (uint256[] memory) {
+        unchecked {
+            /**********************************************************************************************
+        // exactBPTInForTokensOut                                                                    //
+        // (per token)                                                                               //
+        // aO = tokenAmountOut             /        bptIn         \                                  //
+        // b = tokenBalance      a0 = b * | ---------------------  |                                 //
+        // bptIn = bptAmountIn             \     bptTotalSupply    /                                 //
+        // bpt = bptTotalSupply                                                                      //
+        **********************************************************************************************/
+
+            // Since we're computing an amount out, we round down overall. This means rounding down on both the
+            // multiplication and division.
+
+            uint256 bptRatio = bptAmountIn.divDown(bptTotalSupply);
+
+            uint256[] memory amountsOut = new uint256[](balances.length);
+            for (uint256 i = 0; i < balances.length; i++) {
+                // BPT is skipped as those tokens are not the LPs, but rather the preminted and undistributed amount.
+                if (i != bptIndex) {
+                    amountsOut[i] = balances[i].mulDown(bptRatio);
+                }
+            }
+
+            return amountsOut;
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    LEGACY MATH FUNCTIONS
+    //////////////////////////////////////////////////////////////*/
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        unchecked {
+            uint256 c = a * b;
+            require(a == 0 || c / a == b);
+            return c;
+        }
+    }
+
+    function div(
+        uint256 a,
+        uint256 b,
+        bool roundUp
+    ) internal pure returns (uint256) {
+        return roundUp ? divUp(a, b) : divDown(a, b);
+    }
+
+    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
+        unchecked {
+            require(b != 0);
+            return a / b;
+        }
+    }
+
+    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
+        unchecked {
+            require(b != 0);
+
+            if (a == 0) {
+                return 0;
+            } else {
+                return 1 + (a - 1) / b;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,206 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.17;
+
+import "../../../../../../interfaces/Balancer/IVault.sol";
+import "../../../../../../interfaces/Balancer/IERC4626LinearPool.sol";
+import "../../../../../libraries/BoringOwnableUpgradeable.sol";
+import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "./LinearMath.sol";
+
+contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
+    using FixedPoint for uint256;
+
+    struct ImmutableData {
+        address pool;
+        uint256 _BPT_INDEX;
+        IERC20 _mainToken;
+        uint256 _mainIndex;
+        IERC20 _wrappedToken;
+        uint256 _wrappedIndex;
+    }
+
+    address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
+    bytes internal constant EMPTY_BYTES = abi.encode();
+
+    constructor() initializer {}
+
+    function initialize() external initializer {
+        __BoringOwnable_init();
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+
+    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),
+            tokenOut: IERC20(tokenOut),
+            amount: amountIn,
+            // unused data
+            poolId: bytes32(0),
+            lastChangeBlock: 0,
+            from: address(0),
+            to: address(0),
+            userData: EMPTY_BYTES
+        });
+
+        (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());
+
+        uint256 indexIn;
+        uint256 indexOut;
+        ImmutableData memory imd;
+
+        for (uint256 i = 0; i < tokens.length;) {
+            if (tokens[i] == mainToken) {
+                imd._mainToken = mainToken;
+                imd._mainIndex = i;
+            } else if (tokens[i] == IERC20(pool)) {
+                imd.pool = pool;
+                imd._BPT_INDEX = i;
+            } else {
+                imd._wrappedToken = tokens[i];
+                imd._wrappedIndex = i;
+            }
+
+            if (tokens[i] == IERC20(tokenIn)) {
+                indexIn = i;
+            } else if (tokens[i] == IERC20(tokenOut)) {
+                indexOut = i;
+            }
+            unchecked {
+                i++;
+            }
+        }
+
+        return _onSwapGeneral(request, balances, indexIn, indexOut, imd);
+    }
+
+    function _onSwapGeneral(
+        IVault.SwapRequest memory request,
+        uint256[] memory balances,
+        uint256 indexIn,
+        uint256 indexOut,
+        ImmutableData memory imd
+    ) internal view returns (uint256) {
+        // Upscale balances by the scaling factors (taking into account the wrapped token rate)
+        uint256[] memory scalingFactors = IERC4626LinearPool(imd.pool).getScalingFactors();
+        _upscaleArray(balances, scalingFactors);
+
+        (uint256 lowerTarget, uint256 upperTarget) = IERC4626LinearPool(imd.pool).getTargets();
+        LinearMath.Params memory params = LinearMath.Params({
+            fee: IERC4626LinearPool(imd.pool).getSwapFeePercentage(),
+            lowerTarget: lowerTarget,
+            upperTarget: upperTarget
+        });
+
+        assert(request.kind == IVault.SwapKind.GIVEN_IN);
+        // The amount given is for token in, the amount calculated is for token out
+        request.amount = _upscale(request.amount, scalingFactors[indexIn]);
+        uint256 amountOut = _onSwapGivenIn(request, balances, params, imd);
+
+        // amountOut tokens are exiting the Pool, so we round down.
+        return _downscaleDown(amountOut, scalingFactors[indexOut]);
+    }
+
+    function _onSwapGivenIn(
+        IVault.SwapRequest memory request,
+        uint256[] memory balances,
+        LinearMath.Params memory params,
+        ImmutableData memory imd
+    ) internal view returns (uint256) {
+        if (request.tokenIn == IERC20(imd.pool)) {
+            return _swapGivenBptIn(request, balances, params, imd);
+        } else if (request.tokenIn == imd._mainToken) {
+            return _swapGivenMainIn(request, balances, params, imd);
+        } else if (request.tokenIn == imd._wrappedToken) {
+            return _swapGivenWrappedIn(request, balances, params, imd);
+        } else {
+            assert(false);
+        }
+    }
+
+    function _swapGivenBptIn(
+        IVault.SwapRequest memory request,
+        uint256[] memory balances,
+        LinearMath.Params memory params,
+        ImmutableData memory imd
+    ) internal view returns (uint256) {
+        // _require(
+        //     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
+        );
+    }
+
+    function _swapGivenMainIn(
+        IVault.SwapRequest memory request,
+        uint256[] memory balances,
+        LinearMath.Params memory params,
+        ImmutableData memory imd
+    ) internal view returns (uint256) {
+        // _require(
+        //     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);
+    }
+
+    function _swapGivenWrappedIn(
+        IVault.SwapRequest memory request,
+        uint256[] memory balances,
+        LinearMath.Params memory params,
+        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);
+    }
+
+    function _getVirtualSupply(uint256 bptBalance, address pool) internal view returns (uint256) {
+        return (IERC20(pool).totalSupply()).sub(bptBalance);
+    }
+
+    function _upscale(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
+        return FixedPoint.mulDown(amount, scalingFactor);
+    }
+
+    function _downscaleDown(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
+        return FixedPoint.divDown(amount, scalingFactor);
+    }
+
+    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]);
+        }
+    }
+}