{
  "language": "Solidity",
  "sources": {
    "lib/v1-space/src/SpaceFactory.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport { FixedPoint } from \"@balancer-labs/v2-solidity-utils/contracts/math/FixedPoint.sol\";\nimport { BasePoolSplitCodeFactory } from \"@balancer-labs/v2-pool-utils/contracts/factories/BasePoolSplitCodeFactory.sol\";\nimport { IVault } from \"@balancer-labs/v2-vault/contracts/interfaces/IVault.sol\";\nimport { Trust } from \"@sense-finance/v1-utils/src/Trust.sol\";\n\nimport { Space } from \"./Space.sol\";\nimport { Errors, _require } from \"./Errors.sol\";\n\ninterface DividerLike {\n    function series(\n        address, /* adapter */\n        uint256 /* maturity */\n    )\n        external\n        returns (\n            address, /* principal token */\n            address, /* yield token */\n            address, /* sponsor */\n            uint256, /* reward */\n            uint256, /* iscale */\n            uint256, /* mscale */\n            uint256, /* maxscale */\n            uint128, /* issuance */\n            uint128 /* tilt */\n        );\n\n    function pt(address adapter, uint256 maturity) external returns (address);\n\n    function yt(address adapter, uint256 maturity) external returns (address);\n}\n\ncontract SpaceFactory is BasePoolSplitCodeFactory, Trust {\n    /* ========== PUBLIC IMMUTABLES ========== */\n\n    /// @notice Sense Divider\n    DividerLike public immutable divider;\n\n    /* ========== PUBLIC MUTABLE STORAGE ========== */\n\n    /// @notice Pool registry (adapter -> maturity -> pool address)\n    mapping(address => mapping(uint256 => address)) public pools;\n\n    /// @notice Yieldspace config\n    uint256 public ts;\n    uint256 public g1;\n    uint256 public g2;\n\n    /// @notice Oracle flag\n    bool public oracleEnabled;\n\n    /// @notice Oracle flag\n    bool public balancerFeesEnabled;\n\n    constructor(\n        IVault _vault,\n        address _divider,\n        uint256 _ts,\n        uint256 _g1,\n        uint256 _g2,\n        bool _oracleEnabled,\n        bool _balancerFeesEnabled\n    )  BasePoolSplitCodeFactory(_vault, type(Space).creationCode) Trust(msg.sender) {\n        divider = DividerLike(_divider);\n        ts = _ts;\n        g1 = _g1;\n        g2 = _g2;\n        oracleEnabled = _oracleEnabled;\n        balancerFeesEnabled = _balancerFeesEnabled;\n    }\n\n    /// @notice Deploys a new `Space` contract\n    function create(address adapter, uint256 maturity) external returns (address pool) {\n        address pt = divider.pt(adapter, maturity);\n        _require(pt != address(0), Errors.INVALID_SERIES);\n        _require(pools[adapter][maturity] == address(0), Errors.POOL_ALREADY_EXISTS);\n\n        pool = _create(\n            abi.encode(\n                getVault(),\n                adapter,\n                maturity,\n                pt,\n                ts,\n                g1,\n                g2,\n                oracleEnabled,\n                balancerFeesEnabled\n            )\n        );\n\n        pools[adapter][maturity] = pool;\n    }\n\n    function setParams(\n        uint256 _ts,\n        uint256 _g1,\n        uint256 _g2,\n        bool _oracleEnabled,\n        bool _balancerFeesEnabled\n    ) public requiresTrust {\n        // g1 is for swapping Targets to PT and should discount the effective interest\n        _require(_g1 <= FixedPoint.ONE, Errors.INVALID_G1);\n        // g2 is for swapping PT to Target and should mark the effective interest up\n        _require(_g2 >= FixedPoint.ONE, Errors.INVALID_G2);\n\n        ts = _ts;\n        g1 = _g1;\n        g2 = _g2;\n        oracleEnabled = _oracleEnabled;\n        balancerFeesEnabled = _balancerFeesEnabled;\n    }\n\n    /// @notice Authd action to set a pool address on the \"pools\" registry\n    /// @dev Adding a pool to the mapping prevents a new pool from being deployed for that Series from this factory\n    /// @dev Other contracts use this mapping to get the pool address for a specific Series\n    /// @dev This function makes migrations easier b/c the registry can track previously deployed pools\n    /// @dev meaning that pools will never be orphaned\n    function setPool(address adapter, uint256 maturity, address pool) public requiresTrust {\n        _require(divider.pt(adapter, maturity) != address(0), Errors.INVALID_SERIES);\n        _require(pools[adapter][maturity] == address(0), Errors.POOL_ALREADY_EXISTS);\n\n        pools[adapter][maturity] = pool;\n    }\n}"
    },
    "lib/v1-space/src/Space.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\n// External references\nimport { FixedPoint } from \"@balancer-labs/v2-solidity-utils/contracts/math/FixedPoint.sol\";\nimport { Math as BasicMath } from \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\nimport { BalancerPoolToken } from \"@balancer-labs/v2-pool-utils/contracts/BalancerPoolToken.sol\";\nimport { ERC20 } from \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20.sol\";\nimport { LogCompression } from \"@balancer-labs/v2-solidity-utils/contracts/helpers/LogCompression.sol\";\n\nimport { IMinimalSwapInfoPool } from \"@balancer-labs/v2-vault/contracts/interfaces/IMinimalSwapInfoPool.sol\";\nimport { IVault } from \"@balancer-labs/v2-vault/contracts/interfaces/IVault.sol\";\nimport { IERC20 } from \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\nimport { Errors, _require } from \"./Errors.sol\";\nimport { PoolPriceOracle } from \"./oracle/PoolPriceOracle.sol\";\n\ninterface AdapterLike {\n    function scale() external returns (uint256);\n\n    function scaleStored() external view returns (uint256);\n\n    function target() external view returns (address);\n\n    function symbol() external view returns (string memory);\n\n    function name() external view returns (string memory);\n\n    function getUnderlyingPrice() external view returns (uint256);\n}\n\n/*\n                    SPACE\n        *   '*\n                *\n                        *\n                            *\n                    *\n                            *\n                .                      .\n                .                      ;\n                :                  - --+- -\n                !           .          !\n\n*/\n\n/// @notice A Yieldspace implementation extended such that LPs can deposit\n/// [Principal Token, Yield-bearing asset], rather than [Principal Token, Underlying], while keeping the benefits of the\n/// yieldspace invariant (e.g. it can hold [Principal Token, cDAI], rather than [Principal Token, DAI], while still operating\n/// in \"yield space\" for the principal token side. See the YieldSpace paper for more https://yield.is/YieldSpace.pdf)\n/// @dev We use much more internal storage here than in other Sense contracts because it\n/// conforms to Balancer's own style, and we're using several Balancer functions that play nicer if we do.\n/// @dev Requires an external \"Adapter\" contract with a `scale()` function which returns the\n/// current exchange rate from Target to the Underlying asset.\ncontract Space is IMinimalSwapInfoPool, BalancerPoolToken, PoolPriceOracle {\n    using FixedPoint for uint256;\n\n    /* ========== STRUCTURES ========== */\n\n    struct OracleData {\n        uint16 oracleIndex;\n        uint32 oracleSampleInitialTimestamp;\n        bool oracleEnabled;\n        int200 logInvariant;\n    }\n\n    /* ========== CONSTANTS ========== */\n\n    /// @notice Minimum BPT we can have for this pool after initialization\n    uint256 public constant MINIMUM_BPT = 1e6;\n\n    /* ========== PUBLIC IMMUTABLES ========== */\n\n    /// @notice Adapter address for the associated Series\n    address public immutable adapter;\n\n    /// @notice Maturity timestamp for associated Series\n    uint256 public immutable maturity;\n\n    /// @notice Principal Token index (there are only two tokens in this pool, so `targeti` is always just the complement)\n    uint256 public immutable pti;\n\n    /// @notice Yieldspace config indicating the starting point from which the curve shifts (lower numbers mean that it starts closer to the constant sum side)\n    uint256 public immutable ts;\n\n    /// @notice Yieldspace config indicating how much to discount the effective interest when swapping Target to PT\n    uint256 public immutable g1;\n\n    /// @notice Yieldspace config indicating how much to mark the effective interest up when swapping PT to Target\n    uint256 public immutable g2;\n\n    /* ========== INTERNAL IMMUTABLES ========== */\n\n    /// @dev Balancer pool id (as registered with the Balancer Vault)\n    bytes32 internal immutable _poolId;\n\n    /// @dev Token registered at index 0 for this pool\n    IERC20 internal immutable _token0;\n\n    /// @dev Token registered at index one for this pool\n    IERC20 internal immutable _token1;\n\n    /// @dev Factor needed to scale the PT to 18 decimals\n    uint256 internal immutable _scalingFactorPT;\n\n    /// @dev Factor needed to scale the Target token to 18 decimals\n    uint256 internal immutable _scalingFactorTarget;\n\n    /// @dev Balancer Vault\n    IVault internal immutable _vault;\n\n    /// @dev Contract that collects Balancer protocol fees\n    address internal immutable _protocolFeesCollector;\n\n    /* ========== INTERNAL MUTABLE STORAGE ========== */\n\n    /// @dev Scale value for the yield-bearing asset's first `join` (i.e. initialization)\n    uint256 internal _initScale;\n\n    /// @dev Invariant tracking for calculating Balancer protocol fees\n    uint256 internal _lastToken0Reserve;\n    uint256 internal _lastToken1Reserve;\n\n    /// @dev Oracle sample collection metadata\n    OracleData internal oracleData;\n\n    bool internal balancerFeesEnabled;\n\n    constructor(\n        IVault vault,\n        address _adapter,\n        uint256 _maturity,\n        address pt,\n        uint256 _ts,\n        uint256 _g1,\n        uint256 _g2,\n        bool _oracleEnabled,\n        bool _balancerFeesEnabled\n    ) BalancerPoolToken(\n        string(abi.encodePacked(\"Sense Space \", ERC20(pt).name())),\n        string(abi.encodePacked(\"SPACE-\", ERC20(pt).symbol()))\n    ) {\n        bytes32 poolId = vault.registerPool(IVault.PoolSpecialization.TWO_TOKEN);\n\n        address target = AdapterLike(_adapter).target();\n        IERC20[] memory tokens = new IERC20[](2);\n\n        // Ensure that the array of tokens is correctly ordered\n        uint256 _pti = pt < target ? 0 : 1;\n        tokens[_pti] = IERC20(pt);\n        tokens[1 - _pti] = IERC20(target);\n        vault.registerTokens(poolId, tokens, new address[](2));\n\n        // Set Balancer-specific pool config\n        _vault = vault;\n        _poolId = poolId;\n        _token0 = tokens[0];\n        _token1 = tokens[1];\n        _protocolFeesCollector = address(vault.getProtocolFeesCollector());\n\n        _scalingFactorPT = 10**(BasicMath.sub(uint256(18), ERC20(pt).decimals()));\n        _scalingFactorTarget = 10**(BasicMath.sub(uint256(18), ERC20(target).decimals()));\n\n        // Set Yieldspace config\n        g1 = _g1; // Fees are baked into factors `g1` & `g2`,\n        g2 = _g2; // see the \"Fees\" section of the yieldspace paper\n        ts = _ts;\n\n        // Set Space-specific slots\n        pti = _pti;\n        adapter = _adapter;\n        maturity = _maturity;\n        oracleData.oracleEnabled = _oracleEnabled;\n        balancerFeesEnabled = _balancerFeesEnabled;\n    }\n\n    /* ========== BALANCER VAULT HOOKS ========== */\n\n    function onJoinPool(\n        bytes32 poolId,\n        address, /* sender */\n        address recipient,\n        uint256[] memory reserves,\n        uint256 lastChangeBlock,\n        uint256 protocolSwapFeePercentage,\n        bytes memory userData\n    ) external override onlyVault(poolId) returns (uint256[] memory, uint256[] memory) {\n        // Space does not have multiple join types like other Balancer pools,\n        // instead, its `joinPool` always behaves like `EXACT_TOKENS_IN_FOR_BPT_OUT`\n\n        _require(maturity >= block.timestamp, Errors.POOL_PAST_MATURITY);\n\n        (uint256[] memory reqAmountsIn, uint256 minBptOut) = abi.decode(userData, (uint256[], uint256));\n\n        // Upscale both requested amounts and reserves to 18 decimals\n        _upscaleArray(reserves);\n        _upscaleArray(reqAmountsIn);\n\n        if (totalSupply() == 0) {\n            uint256 initScale = AdapterLike(adapter).scale();\n\n            // Convert target balance into Underlying\n            // note We assume scale values will always be 18 decimals\n            uint256 underlyingIn = reqAmountsIn[1 - pti].mulDown(initScale);\n\n            uint256 minBpt = _upscale(_scalingFactorTarget > 1e9 ? 1e4 : MINIMUM_BPT, _scalingFactorTarget);\n\n            // Just like weighted pool 2 token from the balancer v2 monorepo,\n            // we lock MINIMUM_BPT in by minting it for the PT address. This reduces potential\n            // issues with rounding and ensures that this code path will only be executed once\n            _mintPoolTokens(address(0), minBpt);\n\n            uint256 bptToMint = underlyingIn.sub(minBpt);\n\n            // Mint the recipient BPT comensurate with the value of their join in Underlying\n            _mintPoolTokens(recipient, bptToMint);\n\n            _require(bptToMint >= minBptOut, Errors.BPT_OUT_MIN_AMOUNT);\n\n            // Set the scale value all future deposits will be backdated to\n            _initScale = initScale;\n\n            // For the first join, we don't pull any PT, regardless of what the caller requested.\n            // This starts this pool off as synthetic Underlying only, as the yieldspace invariant expects\n            delete reqAmountsIn[pti];\n\n            // Cache starting Target reserves\n            reserves = reqAmountsIn;\n        \n            // Cache new reserves, post join\n            _cacheReserves(reserves);\n\n            // Amounts entering the Pool, so we round up\n            _downscaleUpArray(reqAmountsIn);\n\n            return (reqAmountsIn, new uint256[](2));\n        } else {\n            // Update oracle with upscaled reserves\n            _updateOracle(lastChangeBlock, reserves[pti], reserves[1 - pti]);\n\n            // Calculate fees due before updating bpt balances to determine invariant growth from just swap fees\n            if (balancerFeesEnabled && protocolSwapFeePercentage != 0) {\n                // This doesn't break the YS virtual reserves efficiency trick because, even though we're minting new BPT, \n                // the BPT is still getting denser faster than it's getting diluted, \n                // meaning that it'll never fall below invariant #23 in the YS paper\n                _mintPoolTokens(_protocolFeesCollector, _bptFeeDue(reserves, protocolSwapFeePercentage));\n            }\n\n            (uint256 bptToMint, uint256[] memory amountsIn) = _tokensInForBptOut(reqAmountsIn, reserves);\n\n            _require(bptToMint >= minBptOut, Errors.BPT_OUT_MIN_AMOUNT);\n\n            // `recipient` receives liquidity tokens\n            _mintPoolTokens(recipient, bptToMint);\n\n            // Update reserves for caching\n            //\n            // No risk of overflow as this function will only succeed if the user actually has `amountsIn` and\n            // the max token supply for a well-behaved token is bounded by `uint256 totalSupply`\n            reserves[0] += amountsIn[0];\n            reserves[1] += amountsIn[1];\n\n            // Cache new reserves, post join\n            _cacheReserves(reserves);\n\n            // Amounts entering the Pool, so we round up\n            _downscaleUpArray(amountsIn);\n\n            // Inspired by PR #990 in the balancer v2 monorepo, we always return pt dueProtocolFeeAmounts\n            // to the Vault, and pay protocol fees by minting BPT directly to the protocolFeeCollector instead\n            return (amountsIn, new uint256[](2));\n        }\n    }\n\n    function onExitPool(\n        bytes32 poolId,\n        address sender,\n        address, /* recipient */\n        uint256[] memory reserves,\n        uint256 lastChangeBlock,\n        uint256 protocolSwapFeePercentage,\n        bytes memory userData\n    ) external override onlyVault(poolId) returns (uint256[] memory, uint256[] memory) {\n        // Space does not have multiple exit types like other Balancer pools,\n        // instead, its `exitPool` always behaves like `EXACT_BPT_IN_FOR_TOKENS_OUT`\n\n        // Upscale reserves to 18 decimals\n        _upscaleArray(reserves);\n\n        // Update oracle with upscaled reserves\n        _updateOracle(lastChangeBlock, reserves[pti], reserves[1 - pti]);\n\n        // Calculate fees due before updating bpt balances to determine invariant growth from just swap fees\n        if (balancerFeesEnabled && protocolSwapFeePercentage != 0) {\n            _mintPoolTokens(_protocolFeesCollector, _bptFeeDue(reserves, protocolSwapFeePercentage));\n        }\n\n        // Determine what percentage of the pool the BPT being passed in represents\n        uint256 bptAmountIn = abi.decode(userData, (uint256));\n\n        // Calculate the amount of tokens owed in return for giving that amount of BPT in\n        uint256[] memory amountsOut = new uint256[](2);\n        uint256 _totalSupply = totalSupply();\n        // Even though we are sending tokens to the user, we round both amounts out *up* here, b/c:\n        //     1) Maximizing the number of tokens users get when exiting maximizes the\n        //        number of BPT we mint for users joining afterwards (it maximizes the equation \n        //        totalSupply * amtIn / reserves). As a result, we ensure that the total supply component of the\n        //        numerator is greater than the denominator in the \"marginal rate equation\" (eq. 2) from the YS paper\n        //     2) We lock MINIMUM_BPT away at initialization, which means a number of reserves will\n        //        remain untouched and will function as a buffer for \"off by one\" rounding errors\n        amountsOut[0] = reserves[0].mulUp(bptAmountIn).divUp(_totalSupply);\n        amountsOut[1] = reserves[1].mulUp(bptAmountIn).divUp(_totalSupply);\n\n        // `sender` pays for the liquidity\n        _burnPoolTokens(sender, bptAmountIn);\n\n        // Update reserves for caching\n        reserves[0] = reserves[0].sub(amountsOut[0]);\n        reserves[1] = reserves[1].sub(amountsOut[1]);\n\n        // Cache new invariant and reserves, post exit\n        _cacheReserves(reserves);\n\n        // Amounts are leaving the Pool, so we round down\n        _downscaleDownArray(amountsOut);\n\n        return (amountsOut, new uint256[](2));\n    }\n\n    function onSwap(\n        SwapRequest memory request,\n        uint256 reservesTokenIn,\n        uint256 reservesTokenOut\n    ) external override returns (uint256) {\n        bool ptIn = request.tokenIn == _token0 ? pti == 0 : pti == 1;\n        bool givenIn = request.kind == IVault.SwapKind.GIVEN_IN;\n\n        uint256 scalingFactorTokenIn = _scalingFactor(ptIn);\n        uint256 scalingFactorTokenOut = _scalingFactor(!ptIn);\n\n        // Upscale reserves to 18 decimals\n        reservesTokenIn = _upscale(reservesTokenIn, scalingFactorTokenIn);\n        reservesTokenOut = _upscale(reservesTokenOut, scalingFactorTokenOut);\n\n        if (msg.sender == address(getVault())) {\n            // Given this is a real swap and not a preview, update oracle with upscaled reserves\n            _updateOracle(\n                request.lastChangeBlock,\n                ptIn ? reservesTokenIn : reservesTokenOut,\n                ptIn ? reservesTokenOut: reservesTokenIn\n            );\n        }\n\n        uint256 amountDelta = _upscale(request.amount, givenIn ? scalingFactorTokenIn : scalingFactorTokenOut);\n        \n        uint256 previewedAmount = onSwapPreview(\n            ptIn,\n            givenIn,\n            amountDelta,\n            reservesTokenIn,\n            reservesTokenOut,\n            totalSupply(),\n            AdapterLike(adapter).scale()\n        );\n\n        return givenIn ? _downscaleDown(previewedAmount, scalingFactorTokenOut) : _downscaleUp(previewedAmount, scalingFactorTokenIn);\n    }\n\n    function onSwapPreview(\n        bool ptIn,\n        bool givenIn,\n        uint256 amountDelta,\n        uint256 reservesTokenIn,\n        uint256 reservesTokenOut,\n        uint256 _totalSupply,\n        uint256 scale\n    ) public view returns (uint256) {\n        if (ptIn) {\n            // Add LP supply to PT reserves, as suggested by the yieldspace paper\n            reservesTokenIn = reservesTokenIn.add(_totalSupply);\n\n            // Backdate the Target reserves and convert to Underlying, as if it were still t0 (initialization)\n            reservesTokenOut = reservesTokenOut.mulDown(_initScale);\n        } else {\n            // Backdate the Target reserves and convert to Underlying, as if it were still t0 (initialization)\n            reservesTokenIn = reservesTokenIn.mulDown(_initScale);\n\n            // Add LP supply to PT reserves, as suggested by the yieldspace paper\n            reservesTokenOut = reservesTokenOut.add(_totalSupply);\n        }\n\n        if (givenIn) {\n            // If Target is being swapped in, convert the amountIn to Underlying using present day Scale\n            if (!ptIn) {\n                amountDelta = amountDelta.mulDown(scale);\n            }\n\n            // Determine the amountOut\n            uint256 amountOut = _onSwap(ptIn, true, amountDelta, reservesTokenIn, reservesTokenOut);\n\n            // If PTs are being swapped in, convert the Underlying out back to Target using present day Scale\n            if (ptIn) {\n                amountOut = amountOut.divDown(scale);\n            }\n\n            return amountOut;\n        } else {\n            // If PTs are being swapped in, convert the amountOut from Target to Underlying using present day Scale\n            if (ptIn) {\n                amountDelta = amountDelta.mulDown(scale);\n            }\n\n            // Determine the amountIn\n            uint256 amountIn = _onSwap(ptIn, false, amountDelta, reservesTokenIn, reservesTokenOut);\n\n            // If Target is being swapped in, convert the amountIn back to Target using present day Scale\n            if (!ptIn) {\n                amountIn = amountIn.divDown(scale);\n            }\n\n            return amountIn;\n        }\n    }\n\n    /* ========== INTERNAL JOIN/SWAP ACCOUNTING ========== */\n\n    /// @notice Calculate the max amount of BPT that can be minted from the requested amounts in,\n    // given the ratio of the reserves, and assuming we don't make any swaps\n    function _tokensInForBptOut(uint256[] memory reqAmountsIn, uint256[] memory reserves)\n        internal\n        view\n        returns (uint256, uint256[] memory)\n    {\n        // Disambiguate reserves wrt token type\n        (uint256 pTReserves, uint256 targetReserves) = (reserves[pti], reserves[1 - pti]);\n\n        uint256[] memory amountsIn = new uint256[](2);\n\n        // An empty PT reserve occurs after \n        //     1) Pool initialization\n        //     2) When the entire PT side is swapped out of the pool without implying a negative rate\n        if (pTReserves == 0) {\n            uint256 reqTargetIn = reqAmountsIn[1 - pti];\n            // Mint LP shares according to the relative amount of Target being offered\n            uint256 bptToMint = reqTargetIn.mulDown(_initScale);\n\n            // Pull the entire offered Target\n            amountsIn[1 - pti] = reqTargetIn;\n\n            return (bptToMint, amountsIn);\n        } else {\n            // Disambiguate requested amounts wrt token type\n            (uint256 reqPTIn, uint256 reqTargetIn) = (reqAmountsIn[pti], reqAmountsIn[1 - pti]);\n            uint256 _totalSupply = totalSupply();\n            // Caclulate the percentage of the pool we'd get if we pulled all of the requested Target in\n            uint256 bptToMintTarget = BasicMath.mul(_totalSupply, reqTargetIn) / targetReserves;\n\n            // Caclulate the percentage of the pool we'd get if we pulled all of the requested PT in\n            uint256 bptToMintPT = BasicMath.mul(_totalSupply, reqPTIn) / pTReserves;\n\n            // Determine which amountIn is our limiting factor\n            if (bptToMintTarget < bptToMintPT) {\n                amountsIn[pti] = BasicMath.mul(pTReserves, reqTargetIn) / targetReserves;\n                amountsIn[1 - pti] = reqTargetIn;\n\n                return (bptToMintTarget, amountsIn);\n            } else {\n                amountsIn[pti] = reqPTIn;\n                amountsIn[1 - pti] = BasicMath.mul(targetReserves, reqPTIn) / pTReserves;\n\n                return (bptToMintPT, amountsIn);\n            }\n        }\n    }\n\n    /// @notice Calculate the missing variable in the yield space equation given the direction (PT in vs. out)\n    /// @dev We round in favor of the LPs, meaning that traders get slightly worse prices than they would if we had full\n    /// precision. However, the differences are small (on the order of 1e-11), and should only matter for very small trades.\n    function _onSwap(\n        bool pTIn,\n        bool givenIn,\n        uint256 amountDelta,\n        uint256 reservesTokenIn,\n        uint256 reservesTokenOut\n    ) internal view returns (uint256) {\n        // xPre = token in reserves pre swap\n        // yPre = token out reserves pre swap\n\n        // Seconds until maturity, in 18 decimals\n        // After maturity, this pool becomes a constant sum AMM\n        uint256 ttm = maturity > block.timestamp ? uint256(maturity - block.timestamp) * FixedPoint.ONE : 0;\n\n        // Time shifted partial `t` from the yieldspace paper (`ttm` adjusted by some factor `ts`)\n        uint256 t = ts.mulDown(ttm);\n\n        // Full `t` with fees baked in\n        uint256 a = (pTIn ? g2 : g1).mulUp(t).complement();\n\n        // Pow up for `x1` & `y1` and down for `xOrY2` causes the pow induced error for `xOrYPost`\n        // to tend towards higher values rather than lower.\n        // Effectively we're adding a little bump up for ammountIn, and down for amountOut\n\n        // x1 = xPre ^ a; y1 = yPre ^ a\n        uint256 x1 = reservesTokenIn.powUp(a);\n        uint256 y1 = reservesTokenOut.powUp(a);\n\n        // y2 = (yPre - amountOut) ^ a; x2 = (xPre + amountIn) ^ a\n        //\n        // No overflow risk in the addition as Balancer will only allow an `amountDelta` for tokens coming in\n        // if the user actually has it, and the max token supply for well-behaved tokens is bounded by the uint256 type\n        uint256 newReservesTokenInOrOut = givenIn ? reservesTokenIn + amountDelta : reservesTokenOut.sub(amountDelta);\n        uint256 xOrY2 = newReservesTokenInOrOut.powDown(a);\n\n        // x1 + y1 = xOrY2 + xOrYPost ^ a\n        // -> xOrYPost ^ a = x1 + y1 - x2\n        // -> xOrYPost = (x1 + y1 - xOrY2) ^ (1 / a)\n        uint256 xOrYPost = (x1.add(y1).sub(xOrY2)).powUp(FixedPoint.ONE.divDown(a));\n        _require(!givenIn || reservesTokenOut > xOrYPost, Errors.SWAP_TOO_SMALL);\n\n        if (givenIn) {\n            // Check that PT reserves are greater than \"Underlying\" reserves per section 6.3 of the YS paper\n            _require(\n                pTIn ?\n                newReservesTokenInOrOut >= xOrYPost :\n                newReservesTokenInOrOut <= xOrYPost,\n                Errors.NEGATIVE_RATE\n            );\n\n            // amountOut = yPre - yPost\n            return reservesTokenOut.sub(xOrYPost);\n        } else {\n            _require(\n                pTIn ?\n                xOrYPost >= newReservesTokenInOrOut :\n                xOrYPost <= newReservesTokenInOrOut,\n                Errors.NEGATIVE_RATE\n            );\n\n            // amountIn = xPost - xPre\n            return xOrYPost.sub(reservesTokenIn);\n        }\n    }\n\n    /* ========== PROTOCOL FEE HELPERS ========== */\n\n    /// @notice Determine the growth in the invariant due to swap fees only\n    /// @dev This can't be a view function b/c `Adapter.scale` is not a view function\n    function _bptFeeDue(uint256[] memory reserves, uint256 protocolSwapFeePercentage) internal view returns (uint256) {\n        uint256 ttm = maturity > block.timestamp ? uint256(maturity - block.timestamp) * FixedPoint.ONE : 0;\n        uint256 a = ts.mulDown(ttm).complement();\n\n        // Invariant growth from time only\n        uint256 timeOnlyInvariant = _lastToken0Reserve.powDown(a).add(_lastToken1Reserve.powDown(a));\n\n        // `x` & `y` for the actual invariant, with growth from time and fees\n        uint256 x = reserves[pti].add(totalSupply()).powDown(a);\n        uint256 y = reserves[1 - pti].mulDown(_initScale).powDown(a);\n        uint256 fullInvariant = x.add(y);\n\n        if (fullInvariant <= timeOnlyInvariant) {\n            // Similar to the invariant check in balancer-v2-monorepo/**/WeightedMath.sol,\n            // this shouldn't happen outside of rounding errors, yet we keep this so that those\n            // potential errors don't lead to a locked state\n            return 0;\n        }\n\n        // The formula to calculate fees due is:\n        //\n        // where:\n        //   `g` is the factor by which reserves have grown\n        //   `time-only invariant` = x^a + y^a\n        //   `realized invariant`  = (g*x)^a + (g*y)^a\n        //\n        //              /   realized invariant     \\ ^ (1/a)\n        // `growth` =  |   ----------------------  |\n        //              \\   time-only invariant    /\n        //\n        //\n        // This gets us the proportional growth of all token balances, or `growth`\n        //\n        // We can plug this into the following equation from `WeightedMath` in PR#1111 on the Balancer monorepo:\n        //\n        //             supply * protocol fee * (growth - 1)\n        //                 ---------------------------\n        //                          growth\n        // toMint = --------------------------------------\n        //              1 - protocol fee * (growth - 1)\n        //                ---------------------------\n        //                          growth\n\n        uint256 growth = fullInvariant.divDown(timeOnlyInvariant).powUp(FixedPoint.ONE.divDown(a));\n        uint256 k = protocolSwapFeePercentage.mulDown(growth.sub(FixedPoint.ONE)).divDown(growth);\n\n        return totalSupply().mulDown(k).divDown(k.complement());\n    }\n\n    /// @notice Cache the given reserve amounts\n    /// @dev if the oracle is set, this function will also cache the invariant and supply\n    function _cacheReserves(uint256[] memory reserves) internal {\n        uint256 reservePT = reserves[pti].add(totalSupply());\n        // Calculate the backdated Target reserve\n        uint256 reserveUnderlying = reserves[1 - pti].mulDown(_initScale);\n\n        // Caclulate the invariant and store everything\n        uint256 lastToken0Reserve;\n        uint256 lastToken1Reserve;\n        if (pti == 0) {\n            lastToken0Reserve = reservePT;\n            lastToken1Reserve = reserveUnderlying;\n        } else {\n            lastToken0Reserve = reserveUnderlying;\n            lastToken1Reserve = reservePT;\n        }\n\n        if (oracleData.oracleEnabled) {\n            // If the oracle is enabled, cache the current invarant as well so that callers can determine liquidity\n            uint256 ttm = maturity > block.timestamp ? uint256(maturity - block.timestamp) * FixedPoint.ONE : 0;\n            uint256 a = ts.mulDown(ttm).complement();\n\n            oracleData.logInvariant = int200(\n                LogCompression.toLowResLog(\n                    lastToken0Reserve.powDown(a).add(lastToken1Reserve.powDown(a))\n                )\n            );\n        }\n\n        _lastToken0Reserve = lastToken0Reserve;\n        _lastToken1Reserve = lastToken1Reserve;\n    }\n\n    /* ========== ORACLE HELPERS ========== */\n\n    /// @notice Update the oracle with the current index and timestamp\n    /// @dev Must receive reserves that have already been upscaled\n    /// @dev Acts as a no-op if:\n    ///     * the oracle is not enabled \n    ///     * a price has already been stored for this block\n    ///     * the Target side of the pool doesn't have enough liquidity\n    function _updateOracle(\n        uint256 lastChangeBlock,\n        uint256 balancePT,\n        uint256 balanceTarget\n    ) internal {\n        // The Target side of the pool must have at least 0.01 units of liquidity for us to collect a price sample\n        // note additional liquidity contraints may be enforced outside of this contract via the invariant TWAP\n        if (oracleData.oracleEnabled && block.number > lastChangeBlock && balanceTarget >= 1e16) {\n            // Use equation (2) from the YieldSpace paper to calculate the the marginal rate from the reserves\n            uint256 impliedRate = balancePT.add(totalSupply())\n                .divDown(balanceTarget.mulDown(_initScale));\n\n            // Guard against rounding from exits leading the implied rate to be very slightly negative\n            // NOTE: in a future version of this system, a postive rate invariant for joins/exits will be preserved,\n            // as is currently done for swaps\n            impliedRate = impliedRate < FixedPoint.ONE ? 0 : impliedRate.sub(FixedPoint.ONE);\n\n            // Cacluate the price of one PT in Target terms\n            uint256 pTPriceInTarget = getPriceFromImpliedRate(impliedRate);\n\n            // Following Balancer's oracle conventions, get price of token 1 in terms of token 0 and\n            // and the price of one BPT in terms of token 0\n            //\n            // note b/c reserves are upscaled coming into this function,\n            // price is already upscaled to 18 decimals, regardless of the decimals used for token 0 & 1\n            uint256 pairPrice = pti == 0 ? FixedPoint.ONE.divDown(pTPriceInTarget) : pTPriceInTarget;\n\n            uint256 oracleUpdatedIndex = _processPriceData(\n                oracleData.oracleSampleInitialTimestamp,\n                oracleData.oracleIndex,\n                LogCompression.toLowResLog(pairPrice),\n                // We diverge from Balancer's defaults here by storing implied rate\n                // rather than BPT price in this second slot\n                //\n                // Also note implied rates of less than 1e6 are taken as 1e6, b/c:\n                //     1) `toLowResLog` fails for 0 and 1e6 is precise enough for our needs\n                //     2) 1e6 is the lowest value Balancer passes into this util (min for totalSupply())\n                impliedRate < 1e6 ? LogCompression.toLowResLog(1e6) : LogCompression.toLowResLog(impliedRate),\n                int256(oracleData.logInvariant)\n            );\n\n            if (oracleData.oracleIndex != oracleUpdatedIndex) {\n                oracleData.oracleSampleInitialTimestamp = uint32(block.timestamp);\n                oracleData.oracleIndex = uint16(oracleUpdatedIndex);\n            }\n        }\n    }\n\n    function _getOracleIndex() internal view override returns (uint256) {\n        return oracleData.oracleIndex;\n    }\n\n    /* ========== PUBLIC GETTERS ========== */\n\n    /// @notice Get the APY implied rate for PTs given a price in Target\n    /// @param pTPriceInTarget price of PTs in terms of Target\n    function getImpliedRateFromPrice(uint256 pTPriceInTarget) public view returns (uint256 impliedRate) {\n        if (block.timestamp >= maturity) {\n            return 0;\n        }\n\n        // Calculate the *normed* implied rate from the PT price \n        // (i.e. the effective implied rate of PTs over the period normed by the timeshift param)\n        // (e.g. PTs = 0.9 [U], time to maturity of 0.5 yrs, timeshift param of 10 yrs, the\n        //  normed implied rate = ( 1 / 0.9 ) ^ ( 1 / (0.5 * [1 / 10]) ) - 1 = 722.5% )\n        impliedRate = FixedPoint.ONE\n            .divDown(pTPriceInTarget.mulDown(AdapterLike(adapter).scaleStored()))\n            .powDown(FixedPoint.ONE.divDown(ts).divDown((maturity - block.timestamp) * FixedPoint.ONE))\n            .sub(FixedPoint.ONE);\n    }\n\n    /// @notice Get price of PTs in Target terms given a price for PTs in Target\n    /// @param impliedRate Normed implied rate\n    function getPriceFromImpliedRate(uint256 impliedRate) public view returns (uint256 pTPriceInTarget) {\n        if (block.timestamp >= maturity) {\n            return FixedPoint.ONE;\n        }\n\n        // Calculate the PT price in Target from an implied rate adjusted by the timeshift param,\n        // where the timeshift is a normalization factor applied to the time to maturity\n        pTPriceInTarget = FixedPoint.ONE\n            .divDown(impliedRate.add(FixedPoint.ONE)\n            .powDown(((maturity - block.timestamp) * FixedPoint.ONE)\n            .divDown(FixedPoint.ONE.divDown(ts))))\n            .divDown(AdapterLike(adapter).scaleStored());\n    }\n\n    function getEQReserves(\n        uint256 stretchedRate,\n        uint256 _maturity,\n        uint256 ptReserves,\n        uint256 targetReserves,\n        uint256 _totalSupply,\n        uint256 fee\n    ) public view returns (\n        uint256 eqPTReserves,\n        uint256 eqTargetReserves\n    ) {\n        uint256 a = fee.mulDown(ts.mulDown(_maturity > block.timestamp ? uint256(_maturity - block.timestamp) * FixedPoint.ONE : 0)).complement();\n\n        uint256 initScale = _initScale;\n        uint256 eqPTReservesPartial;\n        {\n            if (initScale == 0) initScale = AdapterLike(adapter).scaleStored();\n            uint256 k = ptReserves.add(_totalSupply).powDown(a).add(\n                targetReserves.mulDown(initScale).powDown(a)\n            );\n            uint256 i = FixedPoint.ONE.add(stretchedRate).powDown(a);\n            i = FixedPoint.ONE.divDown(i).add(FixedPoint.ONE);\n            eqPTReservesPartial = k.divDown(i).powDown(FixedPoint.ONE.divDown(a));\n        }\n\n        return (eqPTReservesPartial.sub(_totalSupply), eqPTReservesPartial.divDown(initScale.mulDown(FixedPoint.ONE.add(stretchedRate))));\n    }\n\n    /// @notice Get the \"fair\" price for the BPT tokens given a correct price for PTs\n    /// in terms of Target. i.e. the price of one BPT in terms of Target using reserves\n    /// as they would be if they accurately reflected the true PT price\n    /// @dev for a technical explanation of the concept, see the description in the following repo:\n    /// https://github.com/makerdao/univ2-lp-oracle/blob/874a59d74d847909cc4a31f0d38ee6b020f6525f/src/UNIV2LPOracle.sol#L26\n    function getFairBPTPrice(uint256 ptTwapDuration)\n        public\n        view\n        returns (uint256 fairBptPriceInTarget)\n    {\n        OracleAverageQuery[] memory queries = new OracleAverageQuery[](1);\n        queries[0] = OracleAverageQuery({\n            variable: Variable.PAIR_PRICE,\n            secs: ptTwapDuration,\n            ago: 1 hours // take the oracle from 1 hour ago + ptTwapDuration ago to 1 hour ago\n        });\n\n        // TWAP read will revert with ORACLE_NOT_INITIALIZED if the buffer has not been filled\n        uint256[] memory results = this.getTimeWeightedAverage(queries);\n        uint256 pTPriceInTarget = pti == 1 ? results[0] : FixedPoint.ONE.divDown(results[0]);\n\n        (, uint256[] memory balances, ) = _vault.getPoolTokens(_poolId);\n        uint256 _totalSupply = totalSupply();\n\n        // Calculate equilibrium reserves given the current reserve balances, and the rate suggested by the TWAR\n        (uint256 eqPTReserves, uint256 eqTargetReserves) = getEQReserves(\n            getImpliedRateFromPrice(pTPriceInTarget),\n            maturity,\n            balances[pti],\n            balances[1 - pti],\n            _totalSupply,\n            FixedPoint.ONE\n        );\n\n        fairBptPriceInTarget = eqTargetReserves.add(eqPTReserves.mulDown(pTPriceInTarget)).divDown(_totalSupply);\n    }\n\n    function adjustedTotalSupply() external returns (uint256) {\n        if (!balancerFeesEnabled) return totalSupply();\n        uint256 protocolSwapFeePercentage = _vault.getProtocolFeesCollector().getSwapFeePercentage();\n        (, uint256[] memory balances, ) = _vault.getPoolTokens(_poolId);\n        _upscaleArray(balances);\n        return totalSupply() + _bptFeeDue(balances, protocolSwapFeePercentage);\n    }\n\n    /// @notice Get token indices for PT and Target\n    function getIndices() public view returns (uint256 _pti, uint256 _targeti) {\n        _pti = pti;\n        _targeti = 1 - pti;\n    }\n\n    /* ========== BALANCER REQUIRED INTERFACE ========== */\n\n    function getPoolId() public view override returns (bytes32) {\n        return _poolId;\n    }\n\n    function getVault() public view returns (IVault) {\n        return _vault;\n    }\n\n    /* ========== BALANCER SCALING FUNCTIONS ========== */\n\n    /// @notice Scaling factors for PT & Target tokens\n    function _scalingFactor(bool pt) internal view returns (uint256) {\n        return pt ? _scalingFactorPT : _scalingFactorTarget;\n    }\n\n    /// @notice Scale number type to 18 decimals if need be\n    function _upscale(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {\n        return BasicMath.mul(amount, scalingFactor);\n    }\n\n    /// @notice Ensure number type is back in its base decimal if need be, rounding down\n    function _downscaleDown(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {\n        return amount / scalingFactor;\n    }\n\n    /// @notice Ensure number type is back in its base decimal if need be, rounding up\n    function _downscaleUp(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {\n        return BasicMath.divUp(amount, scalingFactor);\n    }\n\n    /// @notice Upscale array of token amounts to 18 decimals if need be\n    function _upscaleArray(uint256[] memory amounts) internal view {\n        amounts[pti] = BasicMath.mul(amounts[pti], _scalingFactor(true));\n        amounts[1 - pti] = BasicMath.mul(amounts[1 - pti], _scalingFactor(false));\n    }\n\n    /// @notice Downscale array of token amounts to 18 decimals if need be, rounding down\n    function _downscaleDownArray(uint256[] memory amounts) internal view {\n        amounts[pti] = amounts[pti] / _scalingFactor(true);\n        amounts[1 - pti] = amounts[1 - pti] / _scalingFactor(false);\n    }\n    /// @notice Downscale array of token amounts to 18 decimals if need be, rounding up\n    function _downscaleUpArray(uint256[] memory amounts) internal view {\n        amounts[pti] = BasicMath.divUp(amounts[pti], _scalingFactor(true));\n        amounts[1 - pti] = BasicMath.divUp(amounts[1 - pti], _scalingFactor(false));\n    }\n\n    /* ========== MODIFIERS ========== */\n\n    /// Taken from balancer-v2-monorepo/**/WeightedPool2Tokens.sol\n    modifier onlyVault(bytes32 poolId_) {\n        _require(msg.sender == address(getVault()), Errors.CALLER_NOT_VAULT);\n        _require(poolId_ == getPoolId(), Errors.INVALID_POOL_ID);\n        _;\n    }\n}\n"
    },
    "lib/v1-space/src/Errors.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.7.0;\n\n// solhint-disable\n\n/**\n * @dev Reverts if `condition` is false, with a revert reason containing `errorCode`. Only codes up to 999 are\n * supported.\n */\nfunction _require(bool condition, uint256 errorCode) pure {\n    if (!condition) _revert(errorCode);\n}\n\n/**\n * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported.\n */\nfunction _revert(uint256 errorCode) pure {\n    // We're going to dynamically create a revert string based on the error code, with the following format:\n    // 'SNS#{errorCode}'\n    // where the code is left-padded with zeroes to three digits (so they range from 000 to 999).\n    //\n    // We don't have revert strings embedded in the contract to save bytecode size: it takes much less space to store a\n    // number (8 to 16 bits) than the individual string characters.\n    //\n    // The dynamic string creation algorithm that follows could be implemented in Solidity, but assembly allows for a\n    // much denser implementation, again saving bytecode size. Given this function unconditionally reverts, this is a\n    // safe place to rely on it without worrying about how its usage might affect e.g. memory contents.\n    assembly {\n        // First, we need to compute the ASCII representation of the error code. We assume that it is in the 0-999\n        // range, so we only need to convert three digits. To convert the digits to ASCII, we add 0x30, the value for\n        // the '0' character.\n\n        let units := add(mod(errorCode, 10), 0x30)\n\n        errorCode := div(errorCode, 10)\n        let tenths := add(mod(errorCode, 10), 0x30)\n\n        errorCode := div(errorCode, 10)\n        let hundreds := add(mod(errorCode, 10), 0x30)\n\n        // With the individual characters, we can now construct the full string. The \"SNS#\" part is a known constant\n        // (0x3f534e5323): we simply shift this by 24 (to provide space for the 3 bytes of the error code), and add the\n        // characters to it, each shifted by a multiple of 8.\n        // The revert reason is then shifted left by 200 bits (256 minus the length of the string, 7 characters * 8 bits\n        // per character = 56) to locate it in the most significant part of the 256 slot (the beginning of a byte\n        // array).\n\n        let revertReason := shl(200, add(0x3f534e5323000000, add(add(units, shl(8, tenths)), shl(16, hundreds))))\n\n        // We can now encode the reason in memory, which can be safely overwritten as we're about to revert. The encoded\n        // message will have the following layout:\n        // [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ]\n\n        // The Solidity revert reason identifier is 0x08c739a0, the function selector of the Error(string) function. We\n        // also write zeroes to the next 28 bytes of memory, but those are about to be overwritten.\n        mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n        // Next is the offset to the location of the string, which will be placed immediately after (20 bytes away).\n        mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)\n        // The string length is fixed: 7 characters.\n        mstore(0x24, 7)\n        // Finally, the string itself is stored.\n        mstore(0x44, revertReason)\n\n        // Even if the string is only 7 bytes long, we need to return a full 32 byte slot containing it. The length of\n        // the encoded message is therefore 4 + 32 + 32 + 32 = 100.\n        revert(0, 100)\n    }\n}\n\nlibrary Errors {\n    // Space (using error codes as Space uses ^0.7.0)\n    uint256 internal constant CALLER_NOT_VAULT = 100;\n    uint256 internal constant INVALID_G1 = 101;\n    uint256 internal constant INVALID_G2 = 102;\n    uint256 internal constant INVALID_POOL_ID = 103;\n    uint256 internal constant POOL_ALREADY_EXISTS = 104;\n    uint256 internal constant POOL_PAST_MATURITY = 105;\n    uint256 internal constant SWAP_TOO_SMALL = 106;\n    uint256 internal constant NEGATIVE_RATE = 107;\n    uint256 internal constant BPT_OUT_MIN_AMOUNT = 108;\n    uint256 internal constant INVALID_SERIES = 109;\n}\n"
    },
    "@sense-finance/v1-utils/src/Trust.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.7.0;\n\n/// @notice Ultra minimal authorization logic for smart contracts.\n/// @author From https://github.com/Rari-Capital/solmate/blob/fab107565a51674f3a3b5bfdaacc67f6179b1a9b/src/auth/Trust.sol\nabstract contract Trust {\n    event UserTrustUpdated(address indexed user, bool trusted);\n\n    mapping(address => bool) public isTrusted;\n\n    constructor(address initialUser) {\n        isTrusted[initialUser] = true;\n\n        emit UserTrustUpdated(initialUser, true);\n    }\n\n    function setIsTrusted(address user, bool trusted) public virtual requiresTrust {\n        isTrusted[user] = trusted;\n\n        emit UserTrustUpdated(user, trusted);\n    }\n\n    modifier requiresTrust() {\n        require(isTrusted[msg.sender], \"UNTRUSTED\");\n\n        _;\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IVault.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/ISignaturesValidator.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/ITemporarilyPausable.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/misc/IWETH.sol\";\n\nimport \"./IAsset.sol\";\nimport \"./IAuthorizer.sol\";\nimport \"./IFlashLoanRecipient.sol\";\nimport \"./IProtocolFeesCollector.sol\";\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Full external interface for the Vault core contract - no external or public methods exist in the contract that\n * don't override one of these declarations.\n */\ninterface IVault is ISignaturesValidator, ITemporarilyPausable {\n    // Generalities about the Vault:\n    //\n    // - Whenever documentation refers to 'tokens', it strictly refers to ERC20-compliant token contracts. Tokens are\n    // transferred out of the Vault by calling the `IERC20.transfer` function, and transferred in by calling\n    // `IERC20.transferFrom`. In these cases, the sender must have previously allowed the Vault to use their tokens by\n    // calling `IERC20.approve`. The only deviation from the ERC20 standard that is supported is functions not returning\n    // a boolean value: in these scenarios, a non-reverting call is assumed to be successful.\n    //\n    // - All non-view functions in the Vault are non-reentrant: calling them while another one is mid-execution (e.g.\n    // while execution control is transferred to a token contract during a swap) will result in a revert. View\n    // functions can be called in a re-reentrant way, but doing so might cause them to return inconsistent results.\n    // Contracts calling view functions in the Vault must make sure the Vault has not already been entered.\n    //\n    // - View functions revert if referring to either unregistered Pools, or unregistered tokens for registered Pools.\n\n    // Authorizer\n    //\n    // Some system actions are permissioned, like setting and collecting protocol fees. This permissioning system exists\n    // outside of the Vault in the Authorizer contract: the Vault simply calls the Authorizer to check if the caller\n    // can perform a given action.\n\n    /**\n     * @dev Returns the Vault's Authorizer.\n     */\n    function getAuthorizer() external view returns (IAuthorizer);\n\n    /**\n     * @dev Sets a new Authorizer for the Vault. The caller must be allowed by the current Authorizer to do this.\n     *\n     * Emits an `AuthorizerChanged` event.\n     */\n    function setAuthorizer(IAuthorizer newAuthorizer) external;\n\n    /**\n     * @dev Emitted when a new authorizer is set by `setAuthorizer`.\n     */\n    event AuthorizerChanged(IAuthorizer indexed newAuthorizer);\n\n    // Relayers\n    //\n    // Additionally, it is possible for an account to perform certain actions on behalf of another one, using their\n    // Vault ERC20 allowance and Internal Balance. These accounts are said to be 'relayers' for these Vault functions,\n    // and are expected to be smart contracts with sound authentication mechanisms. For an account to be able to wield\n    // this power, two things must occur:\n    //  - The Authorizer must grant the account the permission to be a relayer for the relevant Vault function. This\n    //    means that Balancer governance must approve each individual contract to act as a relayer for the intended\n    //    functions.\n    //  - Each user must approve the relayer to act on their behalf.\n    // This double protection means users cannot be tricked into approving malicious relayers (because they will not\n    // have been allowed by the Authorizer via governance), nor can malicious relayers approved by a compromised\n    // Authorizer or governance drain user funds, since they would also need to be approved by each individual user.\n\n    /**\n     * @dev Returns true if `user` has approved `relayer` to act as a relayer for them.\n     */\n    function hasApprovedRelayer(address user, address relayer) external view returns (bool);\n\n    /**\n     * @dev Allows `relayer` to act as a relayer for `sender` if `approved` is true, and disallows it otherwise.\n     *\n     * Emits a `RelayerApprovalChanged` event.\n     */\n    function setRelayerApproval(\n        address sender,\n        address relayer,\n        bool approved\n    ) external;\n\n    /**\n     * @dev Emitted every time a relayer is approved or disapproved by `setRelayerApproval`.\n     */\n    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);\n\n    // Internal Balance\n    //\n    // Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later\n    // transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination\n    // when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced\n    // gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users.\n    //\n    // Internal Balance management features batching, which means a single contract call can be used to perform multiple\n    // operations of different kinds, with different senders and recipients, at once.\n\n    /**\n     * @dev Returns `user`'s Internal Balance for a set of tokens.\n     */\n    function getInternalBalance(address user, IERC20[] memory tokens) external view returns (uint256[] memory);\n\n    /**\n     * @dev Performs a set of user balance operations, which involve Internal Balance (deposit, withdraw or transfer)\n     * and plain ERC20 transfers using the Vault's allowance. This last feature is particularly useful for relayers, as\n     * it lets integrators reuse a user's Vault allowance.\n     *\n     * For each operation, if the caller is not `sender`, it must be an authorized relayer for them.\n     */\n    function manageUserBalance(UserBalanceOp[] memory ops) external payable;\n\n    /**\n     * @dev Data for `manageUserBalance` operations, which include the possibility for ETH to be sent and received\n     without manual WETH wrapping or unwrapping.\n     */\n    struct UserBalanceOp {\n        UserBalanceOpKind kind;\n        IAsset asset;\n        uint256 amount;\n        address sender;\n        address payable recipient;\n    }\n\n    // There are four possible operations in `manageUserBalance`:\n    //\n    // - DEPOSIT_INTERNAL\n    // Increases the Internal Balance of the `recipient` account by transferring tokens from the corresponding\n    // `sender`. The sender must have allowed the Vault to use their tokens via `IERC20.approve()`.\n    //\n    // ETH can be used by passing the ETH sentinel value as the asset and forwarding ETH in the call: it will be wrapped\n    // and deposited as WETH. Any ETH amount remaining will be sent back to the caller (not the sender, which is\n    // relevant for relayers).\n    //\n    // Emits an `InternalBalanceChanged` event.\n    //\n    //\n    // - WITHDRAW_INTERNAL\n    // Decreases the Internal Balance of the `sender` account by transferring tokens to the `recipient`.\n    //\n    // ETH can be used by passing the ETH sentinel value as the asset. This will deduct WETH instead, unwrap it and send\n    // it to the recipient as ETH.\n    //\n    // Emits an `InternalBalanceChanged` event.\n    //\n    //\n    // - TRANSFER_INTERNAL\n    // Transfers tokens from the Internal Balance of the `sender` account to the Internal Balance of `recipient`.\n    //\n    // Reverts if the ETH sentinel value is passed.\n    //\n    // Emits an `InternalBalanceChanged` event.\n    //\n    //\n    // - TRANSFER_EXTERNAL\n    // Transfers tokens from `sender` to `recipient`, using the Vault's ERC20 allowance. This is typically used by\n    // relayers, as it lets them reuse a user's Vault allowance.\n    //\n    // Reverts if the ETH sentinel value is passed.\n    //\n    // Emits an `ExternalBalanceTransfer` event.\n\n    enum UserBalanceOpKind { DEPOSIT_INTERNAL, WITHDRAW_INTERNAL, TRANSFER_INTERNAL, TRANSFER_EXTERNAL }\n\n    /**\n     * @dev Emitted when a user's Internal Balance changes, either from calls to `manageUserBalance`, or through\n     * interacting with Pools using Internal Balance.\n     *\n     * Because Internal Balance works exclusively with ERC20 tokens, ETH deposits and withdrawals will use the WETH\n     * address.\n     */\n    event InternalBalanceChanged(address indexed user, IERC20 indexed token, int256 delta);\n\n    /**\n     * @dev Emitted when a user's Vault ERC20 allowance is used by the Vault to transfer tokens to an external account.\n     */\n    event ExternalBalanceTransfer(IERC20 indexed token, address indexed sender, address recipient, uint256 amount);\n\n    // Pools\n    //\n    // There are three specialization settings for Pools, which allow for cheaper swaps at the cost of reduced\n    // functionality:\n    //\n    //  - General: no specialization, suited for all Pools. IGeneralPool is used for swap request callbacks, passing the\n    // balance of all tokens in the Pool. These Pools have the largest swap costs (because of the extra storage reads),\n    // which increase with the number of registered tokens.\n    //\n    //  - Minimal Swap Info: IMinimalSwapInfoPool is used instead of IGeneralPool, which saves gas by only passing the\n    // balance of the two tokens involved in the swap. This is suitable for some pricing algorithms, like the weighted\n    // constant product one popularized by Balancer V1. Swap costs are smaller compared to general Pools, and are\n    // independent of the number of registered tokens.\n    //\n    //  - Two Token: only allows two tokens to be registered. This achieves the lowest possible swap gas cost. Like\n    // minimal swap info Pools, these are called via IMinimalSwapInfoPool.\n\n    enum PoolSpecialization { GENERAL, MINIMAL_SWAP_INFO, TWO_TOKEN }\n\n    /**\n     * @dev Registers the caller account as a Pool with a given specialization setting. Returns the Pool's ID, which\n     * is used in all Pool-related functions. Pools cannot be deregistered, nor can the Pool's specialization be\n     * changed.\n     *\n     * The caller is expected to be a smart contract that implements either `IGeneralPool` or `IMinimalSwapInfoPool`,\n     * depending on the chosen specialization setting. This contract is known as the Pool's contract.\n     *\n     * Note that the same contract may register itself as multiple Pools with unique Pool IDs, or in other words,\n     * multiple Pools may share the same contract.\n     *\n     * Emits a `PoolRegistered` event.\n     */\n    function registerPool(PoolSpecialization specialization) external returns (bytes32);\n\n    /**\n     * @dev Emitted when a Pool is registered by calling `registerPool`.\n     */\n    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, PoolSpecialization specialization);\n\n    /**\n     * @dev Returns a Pool's contract address and specialization setting.\n     */\n    function getPool(bytes32 poolId) external view returns (address, PoolSpecialization);\n\n    /**\n     * @dev Registers `tokens` for the `poolId` Pool. Must be called by the Pool's contract.\n     *\n     * Pools can only interact with tokens they have registered. Users join a Pool by transferring registered tokens,\n     * exit by receiving registered tokens, and can only swap registered tokens.\n     *\n     * Each token can only be registered once. For Pools with the Two Token specialization, `tokens` must have a length\n     * of two, that is, both tokens must be registered in the same `registerTokens` call, and they must be sorted in\n     * ascending order.\n     *\n     * The `tokens` and `assetManagers` arrays must have the same length, and each entry in these indicates the Asset\n     * Manager for the corresponding token. Asset Managers can manage a Pool's tokens via `managePoolBalance`,\n     * depositing and withdrawing them directly, and can even set their balance to arbitrary amounts. They are therefore\n     * expected to be highly secured smart contracts with sound design principles, and the decision to register an\n     * Asset Manager should not be made lightly.\n     *\n     * Pools can choose not to assign an Asset Manager to a given token by passing in the zero address. Once an Asset\n     * Manager is set, it cannot be changed except by deregistering the associated token and registering again with a\n     * different Asset Manager.\n     *\n     * Emits a `TokensRegistered` event.\n     */\n    function registerTokens(\n        bytes32 poolId,\n        IERC20[] memory tokens,\n        address[] memory assetManagers\n    ) external;\n\n    /**\n     * @dev Emitted when a Pool registers tokens by calling `registerTokens`.\n     */\n    event TokensRegistered(bytes32 indexed poolId, IERC20[] tokens, address[] assetManagers);\n\n    /**\n     * @dev Deregisters `tokens` for the `poolId` Pool. Must be called by the Pool's contract.\n     *\n     * Only registered tokens (via `registerTokens`) can be deregistered. Additionally, they must have zero total\n     * balance. For Pools with the Two Token specialization, `tokens` must have a length of two, that is, both tokens\n     * must be deregistered in the same `deregisterTokens` call.\n     *\n     * A deregistered token can be re-registered later on, possibly with a different Asset Manager.\n     *\n     * Emits a `TokensDeregistered` event.\n     */\n    function deregisterTokens(bytes32 poolId, IERC20[] memory tokens) external;\n\n    /**\n     * @dev Emitted when a Pool deregisters tokens by calling `deregisterTokens`.\n     */\n    event TokensDeregistered(bytes32 indexed poolId, IERC20[] tokens);\n\n    /**\n     * @dev Returns detailed information for a Pool's registered token.\n     *\n     * `cash` is the number of tokens the Vault currently holds for the Pool. `managed` is the number of tokens\n     * withdrawn and held outside the Vault by the Pool's token Asset Manager. The Pool's total balance for `token`\n     * equals the sum of `cash` and `managed`.\n     *\n     * Internally, `cash` and `managed` are stored using 112 bits. No action can ever cause a Pool's token `cash`,\n     * `managed` or `total` balance to be greater than 2^112 - 1.\n     *\n     * `lastChangeBlock` is the number of the block in which `token`'s total balance was last modified (via either a\n     * join, exit, swap, or Asset Manager update). This value is useful to avoid so-called 'sandwich attacks', for\n     * example when developing price oracles. A change of zero (e.g. caused by a swap with amount zero) is considered a\n     * change for this purpose, and will update `lastChangeBlock`.\n     *\n     * `assetManager` is the Pool's token Asset Manager.\n     */\n    function getPoolTokenInfo(bytes32 poolId, IERC20 token)\n        external\n        view\n        returns (\n            uint256 cash,\n            uint256 managed,\n            uint256 lastChangeBlock,\n            address assetManager\n        );\n\n    /**\n     * @dev Returns a Pool's registered tokens, the total balance for each, and the latest block when *any* of\n     * the tokens' `balances` changed.\n     *\n     * The order of the `tokens` array is the same order that will be used in `joinPool`, `exitPool`, as well as in all\n     * Pool hooks (where applicable). Calls to `registerTokens` and `deregisterTokens` may change this order.\n     *\n     * If a Pool only registers tokens once, and these are sorted in ascending order, they will be stored in the same\n     * order as passed to `registerTokens`.\n     *\n     * Total balances include both tokens held by the Vault and those withdrawn by the Pool's Asset Managers. These are\n     * the amounts used by joins, exits and swaps. For a detailed breakdown of token balances, use `getPoolTokenInfo`\n     * instead.\n     */\n    function getPoolTokens(bytes32 poolId)\n        external\n        view\n        returns (\n            IERC20[] memory tokens,\n            uint256[] memory balances,\n            uint256 lastChangeBlock\n        );\n\n    /**\n     * @dev Called by users to join a Pool, which transfers tokens from `sender` into the Pool's balance. This will\n     * trigger custom Pool behavior, which will typically grant something in return to `recipient` - often tokenized\n     * Pool shares.\n     *\n     * If the caller is not `sender`, it must be an authorized relayer for them.\n     *\n     * The `assets` and `maxAmountsIn` arrays must have the same length, and each entry indicates the maximum amount\n     * to send for each asset. The amounts to send are decided by the Pool and not the Vault: it just enforces\n     * these maximums.\n     *\n     * If joining a Pool that holds WETH, it is possible to send ETH directly: the Vault will do the wrapping. To enable\n     * this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead of the\n     * WETH address. Note that it is not possible to combine ETH and WETH in the same join. Any excess ETH will be sent\n     * back to the caller (not the sender, which is important for relayers).\n     *\n     * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when\n     * interacting with Pools that register and deregister tokens frequently. If sending ETH however, the array must be\n     * sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the final\n     * `assets` array might not be sorted. Pools with no registered tokens cannot be joined.\n     *\n     * If `fromInternalBalance` is true, the caller's Internal Balance will be preferred: ERC20 transfers will only\n     * be made for the difference between the requested amount and Internal Balance (if any). Note that ETH cannot be\n     * withdrawn from Internal Balance: attempting to do so will trigger a revert.\n     *\n     * This causes the Vault to call the `IBasePool.onJoinPool` hook on the Pool's contract, where Pools implement\n     * their own custom logic. This typically requires additional information from the user (such as the expected number\n     * of Pool shares). This can be encoded in the `userData` argument, which is ignored by the Vault and passed\n     * directly to the Pool's contract, as is `recipient`.\n     *\n     * Emits a `PoolBalanceChanged` event.\n     */\n    function joinPool(\n        bytes32 poolId,\n        address sender,\n        address recipient,\n        JoinPoolRequest memory request\n    ) external payable;\n\n    struct JoinPoolRequest {\n        IAsset[] assets;\n        uint256[] maxAmountsIn;\n        bytes userData;\n        bool fromInternalBalance;\n    }\n\n    /**\n     * @dev Called by users to exit a Pool, which transfers tokens from the Pool's balance to `recipient`. This will\n     * trigger custom Pool behavior, which will typically ask for something in return from `sender` - often tokenized\n     * Pool shares. The amount of tokens that can be withdrawn is limited by the Pool's `cash` balance (see\n     * `getPoolTokenInfo`).\n     *\n     * If the caller is not `sender`, it must be an authorized relayer for them.\n     *\n     * The `tokens` and `minAmountsOut` arrays must have the same length, and each entry in these indicates the minimum\n     * token amount to receive for each token contract. The amounts to send are decided by the Pool and not the Vault:\n     * it just enforces these minimums.\n     *\n     * If exiting a Pool that holds WETH, it is possible to receive ETH directly: the Vault will do the unwrapping. To\n     * enable this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead\n     * of the WETH address. Note that it is not possible to combine ETH and WETH in the same exit.\n     *\n     * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when\n     * interacting with Pools that register and deregister tokens frequently. If receiving ETH however, the array must\n     * be sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the\n     * final `assets` array might not be sorted. Pools with no registered tokens cannot be exited.\n     *\n     * If `toInternalBalance` is true, the tokens will be deposited to `recipient`'s Internal Balance. Otherwise,\n     * an ERC20 transfer will be performed. Note that ETH cannot be deposited to Internal Balance: attempting to\n     * do so will trigger a revert.\n     *\n     * `minAmountsOut` is the minimum amount of tokens the user expects to get out of the Pool, for each token in the\n     * `tokens` array. This array must match the Pool's registered tokens.\n     *\n     * This causes the Vault to call the `IBasePool.onExitPool` hook on the Pool's contract, where Pools implement\n     * their own custom logic. This typically requires additional information from the user (such as the expected number\n     * of Pool shares to return). This can be encoded in the `userData` argument, which is ignored by the Vault and\n     * passed directly to the Pool's contract.\n     *\n     * Emits a `PoolBalanceChanged` event.\n     */\n    function exitPool(\n        bytes32 poolId,\n        address sender,\n        address payable recipient,\n        ExitPoolRequest memory request\n    ) external;\n\n    struct ExitPoolRequest {\n        IAsset[] assets;\n        uint256[] minAmountsOut;\n        bytes userData;\n        bool toInternalBalance;\n    }\n\n    /**\n     * @dev Emitted when a user joins or exits a Pool by calling `joinPool` or `exitPool`, respectively.\n     */\n    event PoolBalanceChanged(\n        bytes32 indexed poolId,\n        address indexed liquidityProvider,\n        IERC20[] tokens,\n        int256[] deltas,\n        uint256[] protocolFeeAmounts\n    );\n\n    enum PoolBalanceChangeKind { JOIN, EXIT }\n\n    // Swaps\n    //\n    // Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. To do this,\n    // they need not trust Pool contracts in any way: all security checks are made by the Vault. They must however be\n    // aware of the Pools' pricing algorithms in order to estimate the prices Pools will quote.\n    //\n    // The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence.\n    // In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'),\n    // and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out').\n    // More complex swaps, such as one token in to multiple tokens out can be achieved by batching together\n    // individual swaps.\n    //\n    // There are two swap kinds:\n    //  - 'given in' swaps, where the amount of tokens in (sent to the Pool) is known, and the Pool determines (via the\n    // `onSwap` hook) the amount of tokens out (to send to the recipient).\n    //  - 'given out' swaps, where the amount of tokens out (received from the Pool) is known, and the Pool determines\n    // (via the `onSwap` hook) the amount of tokens in (to receive from the sender).\n    //\n    // Additionally, it is possible to chain swaps using a placeholder input amount, which the Vault replaces with\n    // the calculated output of the previous swap. If the previous swap was 'given in', this will be the calculated\n    // tokenOut amount. If the previous swap was 'given out', it will use the calculated tokenIn amount. These extended\n    // swaps are known as 'multihop' swaps, since they 'hop' through a number of intermediate tokens before arriving at\n    // the final intended token.\n    //\n    // In all cases, tokens are only transferred in and out of the Vault (or withdrawn from and deposited into Internal\n    // Balance) after all individual swaps have been completed, and the net token balance change computed. This makes\n    // certain swap patterns, such as multihops, or swaps that interact with the same token pair in multiple Pools, cost\n    // much less gas than they would otherwise.\n    //\n    // It also means that under certain conditions it is possible to perform arbitrage by swapping with multiple\n    // Pools in a way that results in net token movement out of the Vault (profit), with no tokens being sent in (only\n    // updating the Pool's internal accounting).\n    //\n    // To protect users from front-running or the market changing rapidly, they supply a list of 'limits' for each token\n    // involved in the swap, where either the maximum number of tokens to send (by passing a positive value) or the\n    // minimum amount of tokens to receive (by passing a negative value) is specified.\n    //\n    // Additionally, a 'deadline' timestamp can also be provided, forcing the swap to fail if it occurs after\n    // this point in time (e.g. if the transaction failed to be included in a block promptly).\n    //\n    // If interacting with Pools that hold WETH, it is possible to both send and receive ETH directly: the Vault will do\n    // the wrapping and unwrapping. To enable this mechanism, the IAsset sentinel value (the zero address) must be\n    // passed in the `assets` array instead of the WETH address. Note that it is possible to combine ETH and WETH in the\n    // same swap. Any excess ETH will be sent back to the caller (not the sender, which is relevant for relayers).\n    //\n    // Finally, Internal Balance can be used when either sending or receiving tokens.\n\n    enum SwapKind { GIVEN_IN, GIVEN_OUT }\n\n    /**\n     * @dev Performs a swap with a single Pool.\n     *\n     * If the swap is 'given in' (the number of tokens to send to the Pool is known), it returns the amount of tokens\n     * taken from the Pool, which must be greater than or equal to `limit`.\n     *\n     * If the swap is 'given out' (the number of tokens to take from the Pool is known), it returns the amount of tokens\n     * sent to the Pool, which must be less than or equal to `limit`.\n     *\n     * Internal Balance usage and the recipient are determined by the `funds` struct.\n     *\n     * Emits a `Swap` event.\n     */\n    function swap(\n        SingleSwap memory singleSwap,\n        FundManagement memory funds,\n        uint256 limit,\n        uint256 deadline\n    ) external payable returns (uint256);\n\n    /**\n     * @dev Data for a single swap executed by `swap`. `amount` is either `amountIn` or `amountOut` depending on\n     * the `kind` value.\n     *\n     * `assetIn` and `assetOut` are either token addresses, or the IAsset sentinel value for ETH (the zero address).\n     * Note that Pools never interact with ETH directly: it will be wrapped to or unwrapped from WETH by the Vault.\n     *\n     * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be\n     * used to extend swap behavior.\n     */\n    struct SingleSwap {\n        bytes32 poolId;\n        SwapKind kind;\n        IAsset assetIn;\n        IAsset assetOut;\n        uint256 amount;\n        bytes userData;\n    }\n\n    /**\n     * @dev Performs a series of swaps with one or multiple Pools. In each individual swap, the caller determines either\n     * the amount of tokens sent to or received from the Pool, depending on the `kind` value.\n     *\n     * Returns an array with the net Vault asset balance deltas. Positive amounts represent tokens (or ETH) sent to the\n     * Vault, and negative amounts represent tokens (or ETH) sent by the Vault. Each delta corresponds to the asset at\n     * the same index in the `assets` array.\n     *\n     * Swaps are executed sequentially, in the order specified by the `swaps` array. Each array element describes a\n     * Pool, the token to be sent to this Pool, the token to receive from it, and an amount that is either `amountIn` or\n     * `amountOut` depending on the swap kind.\n     *\n     * Multihop swaps can be executed by passing an `amount` value of zero for a swap. This will cause the amount in/out\n     * of the previous swap to be used as the amount in for the current one. In a 'given in' swap, 'tokenIn' must equal\n     * the previous swap's `tokenOut`. For a 'given out' swap, `tokenOut` must equal the previous swap's `tokenIn`.\n     *\n     * The `assets` array contains the addresses of all assets involved in the swaps. These are either token addresses,\n     * or the IAsset sentinel value for ETH (the zero address). Each entry in the `swaps` array specifies tokens in and\n     * out by referencing an index in `assets`. Note that Pools never interact with ETH directly: it will be wrapped to\n     * or unwrapped from WETH by the Vault.\n     *\n     * Internal Balance usage, sender, and recipient are determined by the `funds` struct. The `limits` array specifies\n     * the minimum or maximum amount of each token the vault is allowed to transfer.\n     *\n     * `batchSwap` can be used to make a single swap, like `swap` does, but doing so requires more gas than the\n     * equivalent `swap` call.\n     *\n     * Emits `Swap` events.\n     */\n    function batchSwap(\n        SwapKind kind,\n        BatchSwapStep[] memory swaps,\n        IAsset[] memory assets,\n        FundManagement memory funds,\n        int256[] memory limits,\n        uint256 deadline\n    ) external payable returns (int256[] memory);\n\n    /**\n     * @dev Data for each individual swap executed by `batchSwap`. The asset in and out fields are indexes into the\n     * `assets` array passed to that function, and ETH assets are converted to WETH.\n     *\n     * If `amount` is zero, the multihop mechanism is used to determine the actual amount based on the amount in/out\n     * from the previous swap, depending on the swap kind.\n     *\n     * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be\n     * used to extend swap behavior.\n     */\n    struct BatchSwapStep {\n        bytes32 poolId;\n        uint256 assetInIndex;\n        uint256 assetOutIndex;\n        uint256 amount;\n        bytes userData;\n    }\n\n    /**\n     * @dev Emitted for each individual swap performed by `swap` or `batchSwap`.\n     */\n    event Swap(\n        bytes32 indexed poolId,\n        IERC20 indexed tokenIn,\n        IERC20 indexed tokenOut,\n        uint256 amountIn,\n        uint256 amountOut\n    );\n\n    /**\n     * @dev All tokens in a swap are either sent from the `sender` account to the Vault, or from the Vault to the\n     * `recipient` account.\n     *\n     * If the caller is not `sender`, it must be an authorized relayer for them.\n     *\n     * If `fromInternalBalance` is true, the `sender`'s Internal Balance will be preferred, performing an ERC20\n     * transfer for the difference between the requested amount and the User's Internal Balance (if any). The `sender`\n     * must have allowed the Vault to use their tokens via `IERC20.approve()`. This matches the behavior of\n     * `joinPool`.\n     *\n     * If `toInternalBalance` is true, tokens will be deposited to `recipient`'s internal balance instead of\n     * transferred. This matches the behavior of `exitPool`.\n     *\n     * Note that ETH cannot be deposited to or withdrawn from Internal Balance: attempting to do so will trigger a\n     * revert.\n     */\n    struct FundManagement {\n        address sender;\n        bool fromInternalBalance;\n        address payable recipient;\n        bool toInternalBalance;\n    }\n\n    /**\n     * @dev Simulates a call to `batchSwap`, returning an array of Vault asset deltas. Calls to `swap` cannot be\n     * simulated directly, but an equivalent `batchSwap` call can and will yield the exact same result.\n     *\n     * Each element in the array corresponds to the asset at the same index, and indicates the number of tokens (or ETH)\n     * the Vault would take from the sender (if positive) or send to the recipient (if negative). The arguments it\n     * receives are the same that an equivalent `batchSwap` call would receive.\n     *\n     * Unlike `batchSwap`, this function performs no checks on the sender or recipient field in the `funds` struct.\n     * This makes it suitable to be called by off-chain applications via eth_call without needing to hold tokens,\n     * approve them for the Vault, or even know a user's address.\n     *\n     * Note that this function is not 'view' (due to implementation details): the client code must explicitly execute\n     * eth_call instead of eth_sendTransaction.\n     */\n    function queryBatchSwap(\n        SwapKind kind,\n        BatchSwapStep[] memory swaps,\n        IAsset[] memory assets,\n        FundManagement memory funds\n    ) external returns (int256[] memory assetDeltas);\n\n    // Flash Loans\n\n    /**\n     * @dev Performs a 'flash loan', sending tokens to `recipient`, executing the `receiveFlashLoan` hook on it,\n     * and then reverting unless the tokens plus a proportional protocol fee have been returned.\n     *\n     * The `tokens` and `amounts` arrays must have the same length, and each entry in these indicates the loan amount\n     * for each token contract. `tokens` must be sorted in ascending order.\n     *\n     * The 'userData' field is ignored by the Vault, and forwarded as-is to `recipient` as part of the\n     * `receiveFlashLoan` call.\n     *\n     * Emits `FlashLoan` events.\n     */\n    function flashLoan(\n        IFlashLoanRecipient recipient,\n        IERC20[] memory tokens,\n        uint256[] memory amounts,\n        bytes memory userData\n    ) external;\n\n    /**\n     * @dev Emitted for each individual flash loan performed by `flashLoan`.\n     */\n    event FlashLoan(IFlashLoanRecipient indexed recipient, IERC20 indexed token, uint256 amount, uint256 feeAmount);\n\n    // Asset Management\n    //\n    // Each token registered for a Pool can be assigned an Asset Manager, which is able to freely withdraw the Pool's\n    // tokens from the Vault, deposit them, or assign arbitrary values to its `managed` balance (see\n    // `getPoolTokenInfo`). This makes them extremely powerful and dangerous. Even if an Asset Manager only directly\n    // controls one of the tokens in a Pool, a malicious manager could set that token's balance to manipulate the\n    // prices of the other tokens, and then drain the Pool with swaps. The risk of using Asset Managers is therefore\n    // not constrained to the tokens they are managing, but extends to the entire Pool's holdings.\n    //\n    // However, a properly designed Asset Manager smart contract can be safely used for the Pool's benefit,\n    // for example by lending unused tokens out for interest, or using them to participate in voting protocols.\n    //\n    // This concept is unrelated to the IAsset interface.\n\n    /**\n     * @dev Performs a set of Pool balance operations, which may be either withdrawals, deposits or updates.\n     *\n     * Pool Balance management features batching, which means a single contract call can be used to perform multiple\n     * operations of different kinds, with different Pools and tokens, at once.\n     *\n     * For each operation, the caller must be registered as the Asset Manager for `token` in `poolId`.\n     */\n    function managePoolBalance(PoolBalanceOp[] memory ops) external;\n\n    struct PoolBalanceOp {\n        PoolBalanceOpKind kind;\n        bytes32 poolId;\n        IERC20 token;\n        uint256 amount;\n    }\n\n    /**\n     * Withdrawals decrease the Pool's cash, but increase its managed balance, leaving the total balance unchanged.\n     *\n     * Deposits increase the Pool's cash, but decrease its managed balance, leaving the total balance unchanged.\n     *\n     * Updates don't affect the Pool's cash balance, but because the managed balance changes, it does alter the total.\n     * The external amount can be either increased or decreased by this call (i.e., reporting a gain or a loss).\n     */\n    enum PoolBalanceOpKind { WITHDRAW, DEPOSIT, UPDATE }\n\n    /**\n     * @dev Emitted when a Pool's token Asset Manager alters its balance via `managePoolBalance`.\n     */\n    event PoolBalanceManaged(\n        bytes32 indexed poolId,\n        address indexed assetManager,\n        IERC20 indexed token,\n        int256 cashDelta,\n        int256 managedDelta\n    );\n\n    // Protocol Fees\n    //\n    // Some operations cause the Vault to collect tokens in the form of protocol fees, which can then be withdrawn by\n    // permissioned accounts.\n    //\n    // There are two kinds of protocol fees:\n    //\n    //  - flash loan fees: charged on all flash loans, as a percentage of the amounts lent.\n    //\n    //  - swap fees: a percentage of the fees charged by Pools when performing swaps. For a number of reasons, including\n    // swap gas costs and interface simplicity, protocol swap fees are not charged on each individual swap. Rather,\n    // Pools are expected to keep track of how much they have charged in swap fees, and pay any outstanding debts to the\n    // Vault when they are joined or exited. This prevents users from joining a Pool with unpaid debt, as well as\n    // exiting a Pool in debt without first paying their share.\n\n    /**\n     * @dev Returns the current protocol fee module.\n     */\n    function getProtocolFeesCollector() external view returns (IProtocolFeesCollector);\n\n    /**\n     * @dev Safety mechanism to pause most Vault operations in the event of an emergency - typically detection of an\n     * error in some part of the system.\n     *\n     * The Vault can only be paused during an initial time period, after which pausing is forever disabled.\n     *\n     * While the contract is paused, the following features are disabled:\n     * - depositing and transferring internal balance\n     * - transferring external balance (using the Vault's allowance)\n     * - swaps\n     * - joining Pools\n     * - Asset Manager interactions\n     *\n     * Internal Balance can still be withdrawn, and Pools exited.\n     */\n    function setPaused(bool paused) external;\n\n    /**\n     * @dev Returns the Vault's WETH instance.\n     */\n    function WETH() external view returns (IWETH);\n    // solhint-disable-previous-line func-name-mixedcase\n}\n"
    },
    "@balancer-labs/v2-pool-utils/contracts/factories/BasePoolSplitCodeFactory.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BaseSplitCodeFactory.sol\";\nimport \"@balancer-labs/v2-vault/contracts/interfaces/IVault.sol\";\n\n/**\n * @dev Same as `BasePoolFactory`, for Pools whose creation code is so large that the factory cannot hold it.\n */\nabstract contract BasePoolSplitCodeFactory is BaseSplitCodeFactory {\n    IVault private immutable _vault;\n    mapping(address => bool) private _isPoolFromFactory;\n\n    event PoolCreated(address indexed pool);\n\n    constructor(IVault vault, bytes memory creationCode) BaseSplitCodeFactory(creationCode) {\n        _vault = vault;\n    }\n\n    /**\n     * @dev Returns the Vault's address.\n     */\n    function getVault() public view returns (IVault) {\n        return _vault;\n    }\n\n    /**\n     * @dev Returns true if `pool` was created by this factory.\n     */\n    function isPoolFromFactory(address pool) external view returns (bool) {\n        return _isPoolFromFactory[pool];\n    }\n\n    function _create(bytes memory constructorArgs) internal override returns (address) {\n        address pool = super._create(constructorArgs);\n\n        _isPoolFromFactory[pool] = true;\n        emit PoolCreated(pool);\n\n        return pool;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/math/FixedPoint.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"./LogExpMath.sol\";\nimport \"../helpers/BalancerErrors.sol\";\n\n/* solhint-disable private-vars-leading-underscore */\n\nlibrary FixedPoint {\n    uint256 internal constant ONE = 1e18; // 18 decimal places\n    uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14)\n\n    // Minimum base for the power function when the exponent is 'free' (larger than ONE).\n    uint256 internal constant MIN_POW_BASE_FREE_EXPONENT = 0.7e18;\n\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Fixed Point addition is the same as regular checked addition\n\n        uint256 c = a + b;\n        _require(c >= a, Errors.ADD_OVERFLOW);\n        return c;\n    }\n\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Fixed Point addition is the same as regular checked addition\n\n        _require(b <= a, Errors.SUB_OVERFLOW);\n        uint256 c = a - b;\n        return c;\n    }\n\n    function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 product = a * b;\n        _require(a == 0 || product / a == b, Errors.MUL_OVERFLOW);\n\n        return product / ONE;\n    }\n\n    function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 product = a * b;\n        _require(a == 0 || product / a == b, Errors.MUL_OVERFLOW);\n\n        if (product == 0) {\n            return 0;\n        } else {\n            // The traditional divUp formula is:\n            // divUp(x, y) := (x + y - 1) / y\n            // To avoid intermediate overflow in the addition, we distribute the division and get:\n            // divUp(x, y) := (x - 1) / y + 1\n            // Note that this requires x != 0, which we already tested for.\n\n            return ((product - 1) / ONE) + 1;\n        }\n    }\n\n    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {\n        _require(b != 0, Errors.ZERO_DIVISION);\n\n        if (a == 0) {\n            return 0;\n        } else {\n            uint256 aInflated = a * ONE;\n            _require(aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow\n\n            return aInflated / b;\n        }\n    }\n\n    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {\n        _require(b != 0, Errors.ZERO_DIVISION);\n\n        if (a == 0) {\n            return 0;\n        } else {\n            uint256 aInflated = a * ONE;\n            _require(aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow\n\n            // The traditional divUp formula is:\n            // divUp(x, y) := (x + y - 1) / y\n            // To avoid intermediate overflow in the addition, we distribute the division and get:\n            // divUp(x, y) := (x - 1) / y + 1\n            // Note that this requires x != 0, which we already tested for.\n\n            return ((aInflated - 1) / b) + 1;\n        }\n    }\n\n    /**\n     * @dev Returns x^y, assuming both are fixed point numbers, rounding down. The result is guaranteed to not be above\n     * the true value (that is, the error function expected - actual is always positive).\n     */\n    function powDown(uint256 x, uint256 y) internal pure returns (uint256) {\n        uint256 raw = LogExpMath.pow(x, y);\n        uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1);\n\n        if (raw < maxError) {\n            return 0;\n        } else {\n            return sub(raw, maxError);\n        }\n    }\n\n    /**\n     * @dev Returns x^y, assuming both are fixed point numbers, rounding up. The result is guaranteed to not be below\n     * the true value (that is, the error function expected - actual is always negative).\n     */\n    function powUp(uint256 x, uint256 y) internal pure returns (uint256) {\n        uint256 raw = LogExpMath.pow(x, y);\n        uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1);\n\n        return add(raw, maxError);\n    }\n\n    /**\n     * @dev Returns the complement of a value (1 - x), capped to 0 if x is larger than 1.\n     *\n     * Useful when computing the complement for values with some level of relative error, as it strips this error and\n     * prevents intermediate negative values.\n     */\n    function complement(uint256 x) internal pure returns (uint256) {\n        return (x < ONE) ? (ONE - x) : 0;\n    }\n}\n"
    },
    "lib/v1-space/src/oracle/PoolPriceOracle.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// Forked from balancer-v2-monorepo/pkg/pool-utils/contracts/oracle/**\n// at commit ef246cf213541c4120a78f811560f100e5a7e15a\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\n\nimport \"./interfaces/IPriceOracle.sol\";\nimport \"./interfaces/IPoolPriceOracle.sol\";\n\nimport \"./Buffer.sol\";\nimport \"./Samples.sol\";\nimport \"./QueryProcessor.sol\";\n\n/**\n * @dev This module allows Pools to access historical pricing information.\n *\n * It uses a 20 long circular buffer to store past data, where the data within each sample is the result of\n * accumulating live data for no more than two minutes. Therefore, assuming the worst case scenario where new data is\n * updated in every single block, the oldest samples in the buffer (and therefore largest queryable period) will\n * be slightly over 6.5 hours old.\n *\n * Usage of this module requires the caller to keep track of two variables: the latest circular buffer index, and the\n * timestamp when the index last changed. Aditionally, access to the latest circular buffer index must be exposed by\n * implementing `_getOracleIndex`.\n *\n * This contract relies on the `QueryProcessor` linked library to reduce bytecode size.\n */\nabstract contract PoolPriceOracle is IPoolPriceOracle, IPriceOracle {\n    using Buffer for uint256;\n    using Samples for bytes32;\n\n    // Each sample in the buffer accumulates information for up to 20 minutes. This is simply to reduce the size of the\n    // buffer: small time deviations will not have any significant effect.\n    // solhint-disable not-rely-on-time\n    uint256 private constant _MAX_SAMPLE_DURATION = 20 minutes;\n\n    // We use a mapping to simulate an array: the buffer won't grow or shrink, and since we will always use valid\n    // indexes using a mapping saves gas by skipping the bounds checks.\n    mapping(uint256 => bytes32) internal _samples;\n\n    // IPoolPriceOracle\n\n    function getSample(uint256 index)\n        external\n        view\n        override\n        returns (\n            int256 logPairPrice,\n            int256 accLogPairPrice,\n            int256 logBptPrice,\n            int256 accLogBptPrice,\n            int256 logInvariant,\n            int256 accLogInvariant,\n            uint256 timestamp\n        )\n    {\n        _require(index < Buffer.SIZE, Errors.ORACLE_INVALID_INDEX);\n\n        bytes32 sample = _getSample(index);\n        return sample.unpack();\n    }\n\n    function getTotalSamples() external pure override returns (uint256) {\n        return Buffer.SIZE;\n    }\n\n    /**\n     * @dev Manually dirty oracle sample storage slots with dummy data, to reduce the gas cost of the future swaps\n     * that will initialize them. This function is only useful before the oracle has been fully initialized.\n     *\n     * `endIndex` is non-inclusive.\n     */\n    function dirtyUninitializedOracleSamples(uint256 startIndex, uint256 endIndex) external {\n        _require(startIndex < endIndex && endIndex <= Buffer.SIZE, Errors.OUT_OF_BOUNDS);\n\n        // Uninitialized samples are identified by a zero timestamp -- all other fields are ignored,\n        // so any non-zero value with a zero timestamp suffices.\n        bytes32 initSample = Samples.pack(1, 0, 0, 0, 0, 0, 0);\n        for (uint256 i = startIndex; i < endIndex; i++) {\n            if (_samples[i].timestamp() == 0) {\n                _samples[i] = initSample;\n            }\n        }\n    }\n\n    // IPriceOracle\n\n    function getLargestSafeQueryWindow() external pure override returns (uint256) {\n        return 6.66 hours;\n    }\n\n    function getLatest(Variable variable) external view override returns (uint256) {\n        return QueryProcessor.getInstantValue(_samples, variable, _getOracleIndex());\n    }\n\n    function getTimeWeightedAverage(OracleAverageQuery[] memory queries)\n        external\n        view\n        override\n        returns (uint256[] memory results)\n    {\n        results = new uint256[](queries.length);\n        uint256 latestIndex = _getOracleIndex();\n\n        for (uint256 i = 0; i < queries.length; ++i) {\n            results[i] = QueryProcessor.getTimeWeightedAverage(_samples, queries[i], latestIndex);\n        }\n    }\n\n    function getPastAccumulators(OracleAccumulatorQuery[] memory queries)\n        external\n        view\n        override\n        returns (int256[] memory results)\n    {\n        results = new int256[](queries.length);\n        uint256 latestIndex = _getOracleIndex();\n\n        OracleAccumulatorQuery memory query;\n        for (uint256 i = 0; i < queries.length; ++i) {\n            query = queries[i];\n            results[i] = _getPastAccumulator(query.variable, latestIndex, query.ago);\n        }\n    }\n\n    // Internal functions\n\n    /**\n     * @dev Processes new price and invariant data, updating the latest sample or creating a new one.\n     *\n     * Receives the new logarithms of values to store: `logPairPrice`, `logBptPrice` and `logInvariant`, as well the\n     * index of the latest sample and the timestamp of its creation.\n     *\n     * Returns the index of the latest sample. If different from `latestIndex`, the caller should also store the\n     * timestamp, and pass it on future calls to this function.\n     */\n    function _processPriceData(\n        uint256 latestSampleCreationTimestamp,\n        uint256 latestIndex,\n        int256 logPairPrice,\n        int256 logBptPrice,\n        int256 logInvariant\n    ) internal returns (uint256) {\n        // Read latest sample, and compute the next one by updating it with the newly received data.\n        bytes32 sample = _getSample(latestIndex).update(logPairPrice, logBptPrice, logInvariant, block.timestamp);\n\n        // We create a new sample if more than _MAX_SAMPLE_DURATION seconds have elapsed since the creation of the\n        // latest one. In other words, no sample accumulates data over a period larger than _MAX_SAMPLE_DURATION.\n        bool newSample = block.timestamp - latestSampleCreationTimestamp >= _MAX_SAMPLE_DURATION;\n        latestIndex = newSample ? latestIndex.next() : latestIndex;\n\n        // Store the updated or new sample.\n        _samples[latestIndex] = sample;\n\n        return latestIndex;\n    }\n\n    function _getPastAccumulator(\n        IPriceOracle.Variable variable,\n        uint256 latestIndex,\n        uint256 ago\n    ) internal view returns (int256) {\n        return QueryProcessor.getPastAccumulator(_samples, variable, latestIndex, ago);\n    }\n\n    function _findNearestSample(\n        uint256 lookUpDate,\n        uint256 offset,\n        uint256 length\n    ) internal view returns (bytes32 prev, bytes32 next) {\n        return QueryProcessor.findNearestSample(_samples, lookUpDate, offset, length);\n    }\n\n    /**\n     * @dev Returns the sample that corresponds to a given `index`.\n     *\n     * Using this function instead of accessing storage directly results in denser bytecode (since the storage slot is\n     * only computed here).\n     */\n    function _getSample(uint256 index) internal view returns (bytes32) {\n        return _samples[index];\n    }\n\n    /**\n     * @dev Virtual function to be implemented by derived contracts. Must return the current index of the oracle\n     * circular buffer.\n     */\n    function _getOracleIndex() internal view virtual returns (uint256);\n}\n"
    },
    "@balancer-labs/v2-pool-utils/contracts/BalancerPoolToken.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20Permit.sol\";\n\n/**\n * @title Highly opinionated token implementation\n * @author Balancer Labs\n * @dev\n * - Includes functions to increase and decrease allowance as a workaround\n *   for the well-known issue with `approve`:\n *   https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n * - Allows for 'infinite allowance', where an allowance of 0xff..ff is not\n *   decreased by calls to transferFrom\n * - Lets a token holder use `transferFrom` to send their own tokens,\n *   without first setting allowance\n * - Emits 'Approval' events whenever allowance is changed by `transferFrom`\n */\ncontract BalancerPoolToken is ERC20, ERC20Permit {\n    constructor(string memory tokenName, string memory tokenSymbol)\n        ERC20(tokenName, tokenSymbol)\n        ERC20Permit(tokenName)\n    {\n        // solhint-disable-previous-line no-empty-blocks\n    }\n\n    // Overrides\n\n    /**\n     * @dev Override to allow for 'infinite allowance' and let the token owner use `transferFrom` with no self-allowance\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) public override returns (bool) {\n        uint256 currentAllowance = allowance(sender, msg.sender);\n        _require(msg.sender == sender || currentAllowance >= amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE);\n\n        _transfer(sender, recipient, amount);\n\n        if (msg.sender != sender && currentAllowance != uint256(-1)) {\n            // Because of the previous require, we know that if msg.sender != sender then currentAllowance >= amount\n            _approve(sender, msg.sender, currentAllowance - amount);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Override to allow decreasing allowance by more than the current amount (setting it to zero)\n     */\n    function decreaseAllowance(address spender, uint256 amount) public override returns (bool) {\n        uint256 currentAllowance = allowance(msg.sender, spender);\n\n        if (amount >= currentAllowance) {\n            _approve(msg.sender, spender, 0);\n        } else {\n            // No risk of underflow due to if condition\n            _approve(msg.sender, spender, currentAllowance - amount);\n        }\n\n        return true;\n    }\n\n    // Internal functions\n\n    function _mintPoolTokens(address recipient, uint256 amount) internal {\n        _mint(recipient, amount);\n    }\n\n    function _burnPoolTokens(address sender, uint256 amount) internal {\n        _burn(sender, amount);\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/math/Math.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow checks.\n * Adapted from OpenZeppelin's SafeMath library\n */\nlibrary Math {\n    /**\n     * @dev Returns the addition of two unsigned integers of 256 bits, reverting on overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        _require(c >= a, Errors.ADD_OVERFLOW);\n        return c;\n    }\n\n    /**\n     * @dev Returns the addition of two signed integers, reverting on overflow.\n     */\n    function add(int256 a, int256 b) internal pure returns (int256) {\n        int256 c = a + b;\n        _require((b >= 0 && c >= a) || (b < 0 && c < a), Errors.ADD_OVERFLOW);\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers of 256 bits, reverting on overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        _require(b <= a, Errors.SUB_OVERFLOW);\n        uint256 c = a - b;\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two signed integers, reverting on overflow.\n     */\n    function sub(int256 a, int256 b) internal pure returns (int256) {\n        int256 c = a - b;\n        _require((b >= 0 && c <= a) || (b < 0 && c > a), Errors.SUB_OVERFLOW);\n        return c;\n    }\n\n    /**\n     * @dev Returns the largest of two numbers of 256 bits.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a >= b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers of 256 bits.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a * b;\n        _require(a == 0 || c / a == b, Errors.MUL_OVERFLOW);\n        return c;\n    }\n\n    function div(\n        uint256 a,\n        uint256 b,\n        bool roundUp\n    ) internal pure returns (uint256) {\n        return roundUp ? divUp(a, b) : divDown(a, b);\n    }\n\n    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {\n        _require(b != 0, Errors.ZERO_DIVISION);\n        return a / b;\n    }\n\n    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {\n        _require(b != 0, Errors.ZERO_DIVISION);\n\n        if (a == 0) {\n            return 0;\n        } else {\n            return 1 + (a - 1) / b;\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/LogCompression.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"../math/LogExpMath.sol\";\n\n/**\n * @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in\n * a single storage slot, saving gas by performing less storage accesses.\n *\n * Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two\n * 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128.\n */\nlibrary LogCompression {\n    int256 private constant _LOG_COMPRESSION_FACTOR = 1e14;\n    int256 private constant _HALF_LOG_COMPRESSION_FACTOR = 0.5e14;\n\n    /**\n     * @dev Returns the natural logarithm of `value`, dropping most of the decimal places to arrive at a value that,\n     * when passed to `fromLowResLog`, will have a maximum relative error of ~0.05% compared to `value`.\n     *\n     * Values returned from this function should not be mixed with other fixed-point values (as they have a different\n     * number of digits), but can be added or subtracted. Use `fromLowResLog` to undo this process and return to an\n     * 18 decimal places fixed point value.\n     *\n     * Because so much precision is lost, the logarithmic values can be stored using much fewer bits than the original\n     * value required.\n     */\n    function toLowResLog(uint256 value) internal pure returns (int256) {\n        int256 ln = LogExpMath.ln(int256(value));\n\n        // Rounding division for signed numerator\n        int256 lnWithError = (ln > 0 ? ln + _HALF_LOG_COMPRESSION_FACTOR : ln - _HALF_LOG_COMPRESSION_FACTOR);\n        return lnWithError / _LOG_COMPRESSION_FACTOR;\n    }\n\n    /**\n     * @dev Restores `value` from logarithmic space. `value` is expected to be the result of a call to `toLowResLog`,\n     * any other function that returns 4 decimals fixed point logarithms, or the sum of such values.\n     */\n    function fromLowResLog(int256 value) internal pure returns (uint256) {\n        return uint256(LogExpMath.exp(value * _LOG_COMPRESSION_FACTOR));\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\nimport \"./IERC20.sol\";\nimport \"./SafeMath.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin guidelines: functions revert instead\n * of returning `false` on failure. This behavior is nonetheless conventional\n * and does not conflict with the expectations of ERC20 applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is IERC20 {\n    using SafeMath for uint256;\n\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n    uint8 private _decimals;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with\n     * a default value of 18.\n     *\n     * To select a different value for {decimals}, use {_setupDecimals}.\n     *\n     * All three of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n        _decimals = 18;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5,05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is\n     * called.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view returns (uint8) {\n        return _decimals;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(msg.sender, recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(msg.sender, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n        _approve(\n            sender,\n            msg.sender,\n            _allowances[sender][msg.sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE)\n        );\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        _approve(\n            msg.sender,\n            spender,\n            _allowances[msg.sender][spender].sub(subtractedValue, Errors.ERC20_DECREASED_ALLOWANCE_BELOW_ZERO)\n        );\n        return true;\n    }\n\n    /**\n     * @dev Moves tokens `amount` from `sender` to `recipient`.\n     *\n     * This is internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal virtual {\n        _require(sender != address(0), Errors.ERC20_TRANSFER_FROM_ZERO_ADDRESS);\n        _require(recipient != address(0), Errors.ERC20_TRANSFER_TO_ZERO_ADDRESS);\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        _balances[sender] = _balances[sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_BALANCE);\n        _balances[recipient] = _balances[recipient].add(amount);\n        emit Transfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply = _totalSupply.add(amount);\n        _balances[account] = _balances[account].add(amount);\n        emit Transfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        _require(account != address(0), Errors.ERC20_BURN_FROM_ZERO_ADDRESS);\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        _balances[account] = _balances[account].sub(amount, Errors.ERC20_BURN_EXCEEDS_ALLOWANCE);\n        _totalSupply = _totalSupply.sub(amount);\n        emit Transfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Sets {decimals} to a value other than the default one of 18.\n     *\n     * WARNING: This function should only be called from the constructor. Most\n     * applications that interact with token contracts will not expect\n     * {decimals} to ever change, and may work incorrectly if it does.\n     */\n    function _setupDecimals(uint8 decimals_) internal {\n        _decimals = decimals_;\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be to transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IMinimalSwapInfoPool.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"./IBasePool.sol\";\n\n/**\n * @dev Pool contracts with the MinimalSwapInfo or TwoToken specialization settings should implement this interface.\n *\n * This is called by the Vault when a user calls `IVault.swap` or `IVault.batchSwap` to swap with this Pool.\n * Returns the number of tokens the Pool will grant to the user in a 'given in' swap, or that the user will grant\n * to the pool in a 'given out' swap.\n *\n * This can often be implemented by a `view` function, since many pricing algorithms don't need to track state\n * changes in swaps. However, contracts implementing this in non-view functions should check that the caller is\n * indeed the Vault.\n */\ninterface IMinimalSwapInfoPool is IBasePool {\n    function onSwap(\n        SwapRequest memory swapRequest,\n        uint256 currentBalanceTokenIn,\n        uint256 currentBalanceTokenOut\n    ) external returns (uint256 amount);\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
    },
    "lib/v1-space/src/oracle/Buffer.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// Forked from balancer-v2-monorepo/pkg/pool-utils/contracts/oracle/**\n// at commit ef246cf213541c4120a78f811560f100e5a7e15a\n\npragma solidity ^0.7.0;\n\nlibrary Buffer {\n    // The buffer is a circular storage structure with 20 slots.\n    // solhint-disable-next-line private-vars-leading-underscore\n    uint256 internal constant SIZE = 20;\n\n    /**\n     * @dev Returns the index of the element before the one pointed by `index`.\n     */\n    function prev(uint256 index) internal pure returns (uint256) {\n        return sub(index, 1);\n    }\n\n    /**\n     * @dev Returns the index of the element after the one pointed by `index`.\n     */\n    function next(uint256 index) internal pure returns (uint256) {\n        return add(index, 1);\n    }\n\n    /**\n     * @dev Returns the index of an element `offset` slots after the one pointed by `index`.\n     */\n    function add(uint256 index, uint256 offset) internal pure returns (uint256) {\n        return (index + offset) % SIZE;\n    }\n\n    /**\n     * @dev Returns the index of an element `offset` slots before the one pointed by `index`.\n     */\n    function sub(uint256 index, uint256 offset) internal pure returns (uint256) {\n        return (index + SIZE - offset) % SIZE;\n    }\n}\n"
    },
    "lib/v1-space/src/oracle/Samples.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// Forked from balancer-v2-monorepo/pkg/pool-utils/contracts/oracle/**\n// at commit ef246cf213541c4120a78f811560f100e5a7e15a\n\npragma solidity ^0.7.0;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/WordCodec.sol\";\n\nimport \"./interfaces/IPriceOracle.sol\";\n\n/**\n * @dev This library provides functions to help manipulating samples for Pool Price Oracles. It handles updates,\n * encoding, and decoding of samples.\n *\n * Each sample holds the timestamp of its last update, plus information about three pieces of data: the price pair, the\n * price of BPT (the associated Pool token), and the invariant.\n *\n * Prices and invariant are not stored directly: instead, we store their logarithm. These are known as the 'instant'\n * values: the exact value at that timestamp.\n *\n * Additionally, for each value we keep an accumulator with the sum of all past values, each weighted by the time\n * elapsed since the previous update. This lets us later subtract accumulators at different points in time and divide by\n * the time elapsed between them, arriving at the geometric mean of the values (also known as log-average).\n *\n * All samples are stored in a single 256 bit word with the following structure:\n *\n * [    log pair price     |        bpt price      |       invariant       |  timestamp ]\n * [ instant | accumulator | instant | accumulator | instant | accumulator |            ]\n * [  int22  |    int53    |  int22  |    int53    |  int22  |    int53    |    uint31  ]\n * MSB                                                                                LSB\n *\n * Assuming the timestamp doesn't overflow (which holds until the year 2038), the largest elapsed time is 2^31, which\n * means the largest possible accumulator value is 2^21 * 2^31, which can be represented using a signed 53 bit integer.\n */\nlibrary Samples {\n    using WordCodec for int256;\n    using WordCodec for uint256;\n    using WordCodec for bytes32;\n\n    uint256 internal constant _TIMESTAMP_OFFSET = 0;\n    uint256 internal constant _ACC_LOG_INVARIANT_OFFSET = 31;\n    uint256 internal constant _INST_LOG_INVARIANT_OFFSET = 84;\n    uint256 internal constant _ACC_LOG_BPT_PRICE_OFFSET = 106;\n    uint256 internal constant _INST_LOG_BPT_PRICE_OFFSET = 159;\n    uint256 internal constant _ACC_LOG_PAIR_PRICE_OFFSET = 181;\n    uint256 internal constant _INST_LOG_PAIR_PRICE_OFFSET = 234;\n\n    /**\n     * @dev Updates a sample, accumulating the new data based on the elapsed time since the previous update. Returns the\n     * updated sample.\n     *\n     * IMPORTANT: This function does not perform any arithmetic checks. In particular, it assumes the caller will never\n     * pass values that cannot be represented as 22 bit signed integers. Additionally, it also assumes\n     * `currentTimestamp` is greater than `sample`'s timestamp.\n     */\n    function update(\n        bytes32 sample,\n        int256 instLogPairPrice,\n        int256 instLogBptPrice,\n        int256 instLogInvariant,\n        uint256 currentTimestamp\n    ) internal pure returns (bytes32) {\n        // Because elapsed can be represented as a 31 bit unsigned integer, and the received values can be represented\n        // as 22 bit signed integers, we don't need to perform checked arithmetic.\n\n        int256 elapsed = int256(currentTimestamp - timestamp(sample));\n        int256 accLogPairPrice = _accLogPairPrice(sample) + instLogPairPrice * elapsed;\n        int256 accLogBptPrice = _accLogBptPrice(sample) + instLogBptPrice * elapsed;\n        int256 accLogInvariant = _accLogInvariant(sample) + instLogInvariant * elapsed;\n\n        return\n            pack(\n                instLogPairPrice,\n                accLogPairPrice,\n                instLogBptPrice,\n                accLogBptPrice,\n                instLogInvariant,\n                accLogInvariant,\n                currentTimestamp\n            );\n    }\n\n    /**\n     * @dev Returns the instant value stored in `sample` for `variable`.\n     */\n    function instant(bytes32 sample, IPriceOracle.Variable variable) internal pure returns (int256) {\n        if (variable == IPriceOracle.Variable.PAIR_PRICE) {\n            return _instLogPairPrice(sample);\n        } else if (variable == IPriceOracle.Variable.BPT_PRICE) {\n            return _instLogBptPrice(sample);\n        } else {\n            // variable == IPriceOracle.Variable.INVARIANT\n            return _instLogInvariant(sample);\n        }\n    }\n\n    /**\n     * @dev Returns the accumulator value stored in `sample` for `variable`.\n     */\n    function accumulator(bytes32 sample, IPriceOracle.Variable variable) internal pure returns (int256) {\n        if (variable == IPriceOracle.Variable.PAIR_PRICE) {\n            return _accLogPairPrice(sample);\n        } else if (variable == IPriceOracle.Variable.BPT_PRICE) {\n            return _accLogBptPrice(sample);\n        } else {\n            // variable == IPriceOracle.Variable.INVARIANT\n            return _accLogInvariant(sample);\n        }\n    }\n\n    /**\n     * @dev Returns `sample`'s timestamp.\n     */\n    function timestamp(bytes32 sample) internal pure returns (uint256) {\n        return sample.decodeUint31(_TIMESTAMP_OFFSET);\n    }\n\n    /**\n     * @dev Returns `sample`'s instant value for the logarithm of the pair price.\n     */\n    function _instLogPairPrice(bytes32 sample) private pure returns (int256) {\n        return sample.decodeInt22(_INST_LOG_PAIR_PRICE_OFFSET);\n    }\n\n    /**\n     * @dev Returns `sample`'s accumulator of the logarithm of the pair price.\n     */\n    function _accLogPairPrice(bytes32 sample) private pure returns (int256) {\n        return sample.decodeInt53(_ACC_LOG_PAIR_PRICE_OFFSET);\n    }\n\n    /**\n     * @dev Returns `sample`'s instant value for the logarithm of the BPT price.\n     */\n    function _instLogBptPrice(bytes32 sample) private pure returns (int256) {\n        return sample.decodeInt22(_INST_LOG_BPT_PRICE_OFFSET);\n    }\n\n    /**\n     * @dev Returns `sample`'s accumulator of the logarithm of the BPT price.\n     */\n    function _accLogBptPrice(bytes32 sample) private pure returns (int256) {\n        return sample.decodeInt53(_ACC_LOG_BPT_PRICE_OFFSET);\n    }\n\n    /**\n     * @dev Returns `sample`'s instant value for the logarithm of the invariant.\n     */\n    function _instLogInvariant(bytes32 sample) private pure returns (int256) {\n        return sample.decodeInt22(_INST_LOG_INVARIANT_OFFSET);\n    }\n\n    /**\n     * @dev Returns `sample`'s accumulator of the logarithm of the invariant.\n     */\n    function _accLogInvariant(bytes32 sample) private pure returns (int256) {\n        return sample.decodeInt53(_ACC_LOG_INVARIANT_OFFSET);\n    }\n\n    /**\n     * @dev Returns a sample created by packing together its components.\n     */\n    function pack(\n        int256 instLogPairPrice,\n        int256 accLogPairPrice,\n        int256 instLogBptPrice,\n        int256 accLogBptPrice,\n        int256 instLogInvariant,\n        int256 accLogInvariant,\n        uint256 _timestamp\n    ) internal pure returns (bytes32) {\n        return\n            instLogPairPrice.encodeInt22(_INST_LOG_PAIR_PRICE_OFFSET) |\n            accLogPairPrice.encodeInt53(_ACC_LOG_PAIR_PRICE_OFFSET) |\n            instLogBptPrice.encodeInt22(_INST_LOG_BPT_PRICE_OFFSET) |\n            accLogBptPrice.encodeInt53(_ACC_LOG_BPT_PRICE_OFFSET) |\n            instLogInvariant.encodeInt22(_INST_LOG_INVARIANT_OFFSET) |\n            accLogInvariant.encodeInt53(_ACC_LOG_INVARIANT_OFFSET) |\n            _timestamp.encodeUint(_TIMESTAMP_OFFSET); // Using 31 bits\n    }\n\n    /**\n     * @dev Unpacks a sample into its components.\n     */\n    function unpack(bytes32 sample)\n        internal\n        pure\n        returns (\n            int256 logPairPrice,\n            int256 accLogPairPrice,\n            int256 logBptPrice,\n            int256 accLogBptPrice,\n            int256 logInvariant,\n            int256 accLogInvariant,\n            uint256 _timestamp\n        )\n    {\n        logPairPrice = _instLogPairPrice(sample);\n        accLogPairPrice = _accLogPairPrice(sample);\n        logBptPrice = _instLogBptPrice(sample);\n        accLogBptPrice = _accLogBptPrice(sample);\n        logInvariant = _instLogInvariant(sample);\n        accLogInvariant = _accLogInvariant(sample);\n        _timestamp = timestamp(sample);\n    }\n}\n"
    },
    "lib/v1-space/src/oracle/QueryProcessor.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// Forked from balancer-v2-monorepo/pkg/pool-utils/contracts/oracle/**\n// at commit ef246cf213541c4120a78f811560f100e5a7e15a\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/LogCompression.sol\";\n\nimport \"./interfaces/IPriceOracle.sol\";\n\nimport \"./Buffer.sol\";\nimport \"./Samples.sol\";\n\n/**\n * @dev Auxiliary library for PoolPriceOracle, offloading most of the query code to reduce bytecode size by using this\n * as a linked library. The downside is an extra DELEGATECALL is added (2600 gas as of the Berlin hardfork), but the\n * bytecode size gains are so big (specially of the oracle contract does not use `LogCompression.fromLowResLog`) that\n * it is worth it.\n */\nlibrary QueryProcessor {\n    using Buffer for uint256;\n    using Samples for bytes32;\n    using LogCompression for int256;\n\n    /**\n     * @dev Returns the value for `variable` at the indexed sample.\n     */\n    function getInstantValue(\n        mapping(uint256 => bytes32) storage samples,\n        IPriceOracle.Variable variable,\n        uint256 index\n    ) external view returns (uint256) {\n        bytes32 sample = samples[index];\n        _require(sample.timestamp() > 0, Errors.ORACLE_NOT_INITIALIZED);\n\n        int256 rawInstantValue = sample.instant(variable);\n        return LogCompression.fromLowResLog(rawInstantValue);\n    }\n\n    /**\n     * @dev Returns the time average weighted price corresponding to `query`.\n     */\n    function getTimeWeightedAverage(\n        mapping(uint256 => bytes32) storage samples,\n        IPriceOracle.OracleAverageQuery memory query,\n        uint256 latestIndex\n    ) external view returns (uint256) {\n        _require(query.secs != 0, Errors.ORACLE_BAD_SECS);\n\n        int256 beginAccumulator = getPastAccumulator(samples, query.variable, latestIndex, query.ago + query.secs);\n        int256 endAccumulator = getPastAccumulator(samples, query.variable, latestIndex, query.ago);\n        return LogCompression.fromLowResLog((endAccumulator - beginAccumulator) / int256(query.secs));\n    }\n\n    /**\n     * @dev Returns the value of the accumulator for `variable` `ago` seconds ago. `latestIndex` must be the index of\n     * the latest sample in the buffer.\n     *\n     * Reverts under the following conditions:\n     *  - if the buffer is empty.\n     *  - if querying past information and the buffer has not been fully initialized.\n     *  - if querying older information than available in the buffer. Note that a full buffer guarantees queries for the\n     *    past 34 hours will not revert.\n     *\n     * If requesting information for a timestamp later than the latest one, it is extrapolated using the latest\n     * available data.\n     *\n     * When no exact information is available for the requested past timestamp (as usually happens, since at most one\n     * timestamp is stored every two minutes), it is estimated by performing linear interpolation using the closest\n     * values. This process is guaranteed to complete performing at most 10 storage reads.\n     */\n    function getPastAccumulator(\n        mapping(uint256 => bytes32) storage samples,\n        IPriceOracle.Variable variable,\n        uint256 latestIndex,\n        uint256 ago\n    ) public view returns (int256) {\n        // solhint-disable not-rely-on-time\n        // `ago` must not be before the epoch.\n        _require(block.timestamp >= ago, Errors.ORACLE_INVALID_SECONDS_QUERY);\n        uint256 lookUpTime = block.timestamp - ago;\n\n        bytes32 latestSample = samples[latestIndex];\n        uint256 latestTimestamp = latestSample.timestamp();\n\n        // The latest sample only has a non-zero timestamp if no data was ever processed and stored in the buffer.\n        _require(latestTimestamp > 0, Errors.ORACLE_NOT_INITIALIZED);\n\n        if (latestTimestamp <= lookUpTime) {\n            // The accumulator at times ahead of the latest one are computed by extrapolating the latest data. This is\n            // equivalent to the instant value not changing between the last timestamp and the look up time.\n\n            // We can use unchecked arithmetic since the accumulator can be represented in 53 bits, timestamps in 31\n            // bits, and the instant value in 22 bits.\n            uint256 elapsed = lookUpTime - latestTimestamp;\n            return latestSample.accumulator(variable) + (latestSample.instant(variable) * int256(elapsed));\n        } else {\n            // The look up time is before the latest sample, but we need to make sure that it is not before the oldest\n            // sample as well.\n\n            // Since we use a circular buffer, the oldest sample is simply the next one.\n            uint256 bufferLength;\n            uint256 oldestIndex = latestIndex.next();\n            {\n                // Local scope used to prevent stack-too-deep errors.\n                bytes32 oldestSample = samples[oldestIndex];\n                uint256 oldestTimestamp = oldestSample.timestamp();\n\n                if (oldestTimestamp > 0) {\n                    // If the oldest timestamp is not zero, it means the buffer was fully initialized.\n                    bufferLength = Buffer.SIZE;\n                } else {\n                    // If the buffer was not fully initialized, we haven't wrapped around it yet,\n                    // and can treat it as a regular array where the oldest index is the first one,\n                    // and the length the number of samples.\n                    bufferLength = oldestIndex; // Equal to latestIndex.next()\n                    oldestIndex = 0;\n                    oldestTimestamp = samples[0].timestamp();\n                }\n\n                // Finally check that the look up time is not previous to the oldest timestamp.\n                _require(oldestTimestamp <= lookUpTime, Errors.ORACLE_QUERY_TOO_OLD);\n            }\n\n            // Perform binary search to find nearest samples to the desired timestamp.\n            (bytes32 prev, bytes32 next) = findNearestSample(samples, lookUpTime, oldestIndex, bufferLength);\n\n            // `next`'s timestamp is guaranteed to be larger than `prev`'s, so we can skip checked arithmetic.\n            uint256 samplesTimeDiff = next.timestamp() - prev.timestamp();\n\n            if (samplesTimeDiff > 0) {\n                // We estimate the accumulator at the requested look up time by interpolating linearly between the\n                // previous and next accumulators.\n\n                // We can use unchecked arithmetic since the accumulators can be represented in 53 bits, and timestamps\n                // in 31 bits.\n                int256 samplesAccDiff = next.accumulator(variable) - prev.accumulator(variable);\n                uint256 elapsed = lookUpTime - prev.timestamp();\n                return prev.accumulator(variable) + ((samplesAccDiff * int256(elapsed)) / int256(samplesTimeDiff));\n            } else {\n                // Rarely, one of the samples will have the exact requested look up time, which is indicated by `prev`\n                // and `next` being the same. In this case, we simply return the accumulator at that point in time.\n                return prev.accumulator(variable);\n            }\n        }\n    }\n\n    /**\n     * @dev Finds the two samples with timestamps before and after `lookUpDate`. If one of the samples matches exactly,\n     * both `prev` and `next` will be it. `offset` is the index of the oldest sample in the buffer. `length` is the size\n     * of the samples list.\n     *\n     * Assumes `lookUpDate` is greater or equal than the timestamp of the oldest sample, and less or equal than the\n     * timestamp of the latest sample.\n     */\n    function findNearestSample(\n        mapping(uint256 => bytes32) storage samples,\n        uint256 lookUpDate,\n        uint256 offset,\n        uint256 length\n    ) public view returns (bytes32 prev, bytes32 next) {\n        // We're going to perform a binary search in the circular buffer, which requires it to be sorted. To achieve\n        // this, we offset all buffer accesses by `offset`, making the first element the oldest one.\n\n        // Auxiliary variables in a typical binary search: we will look at some value `mid` between `low` and `high`,\n        // periodically increasing `low` or decreasing `high` until we either find a match or determine the element is\n        // not in the array.\n        uint256 low = 0;\n        uint256 high = length - 1;\n        uint256 mid;\n\n        // If the search fails and no sample has a timestamp of `lookUpDate` (as is the most common scenario), `sample`\n        // will be either the sample with the largest timestamp smaller than `lookUpDate`, or the one with the smallest\n        // timestamp larger than `lookUpDate`.\n        bytes32 sample;\n        uint256 sampleTimestamp;\n\n        while (low <= high) {\n            // Mid is the floor of the average.\n            uint256 midWithoutOffset = (high + low) / 2;\n\n            // Recall that the buffer is not actually sorted: we need to apply the offset to access it in a sorted way.\n            mid = midWithoutOffset.add(offset);\n            sample = samples[mid];\n            sampleTimestamp = sample.timestamp();\n\n            if (sampleTimestamp < lookUpDate) {\n                // If the mid sample is bellow the look up date, then increase the low index to start from there.\n                low = midWithoutOffset + 1;\n            } else if (sampleTimestamp > lookUpDate) {\n                // If the mid sample is above the look up date, then decrease the high index to start from there.\n\n                // We can skip checked arithmetic: it is impossible for `high` to ever be 0, as a scenario where `low`\n                // equals 0 and `high` equals 1 would result in `low` increasing to 1 in the previous `if` clause.\n                high = midWithoutOffset - 1;\n            } else {\n                // sampleTimestamp == lookUpDate\n                // If we have an exact match, return the sample as both `prev` and `next`.\n                return (sample, sample);\n            }\n        }\n\n        // In case we reach here, it means we didn't find exactly the sample we where looking for.\n        return sampleTimestamp < lookUpDate ? (sample, samples[mid.next()]) : (samples[mid.prev()], sample);\n    }\n}\n"
    },
    "lib/v1-space/src/oracle/interfaces/IPoolPriceOracle.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// Forked from balancer-v2-monorepo/pkg/pool-utils/contracts/oracle/**\n// at commit ef246cf213541c4120a78f811560f100e5a7e15a\n\npragma solidity ^0.7.0;\n\ninterface IPoolPriceOracle {\n    /**\n     * @dev Returns the raw data of the sample at `index`.\n     */\n    function getSample(uint256 index)\n        external\n        view\n        returns (\n            int256 logPairPrice,\n            int256 accLogPairPrice,\n            int256 logBptPrice,\n            int256 accLogBptPrice,\n            int256 logInvariant,\n            int256 accLogInvariant,\n            uint256 timestamp\n        );\n\n    /**\n     * @dev Returns the total number of samples.\n     */\n    function getTotalSamples() external view returns (uint256);\n}\n"
    },
    "lib/v1-space/src/oracle/interfaces/IPriceOracle.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// Forked from balancer-v2-monorepo/pkg/pool-utils/contracts/oracle/**\n// at commit ef246cf213541c4120a78f811560f100e5a7e15a\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\n/**\n * @dev Interface for querying historical data from a Pool that can be used as a Price Oracle.\n *\n * This lets third parties retrieve average prices of tokens held by a Pool over a given period of time, as well as the\n * price of the Pool share token (BPT) and invariant. Since the invariant is a sensible measure of Pool liquidity, it\n * can be used to compare two different price sources, and choose the most liquid one.\n *\n * Once the oracle is fully initialized, all queries are guaranteed to succeed as long as they require no data that\n * is not older than the largest safe query window.\n */\ninterface IPriceOracle {\n    // The three values that can be queried:\n    //\n    // - PAIR_PRICE: the price of the tokens in the Pool, expressed as the price of the second token in units of the\n    //   first token. For example, if token A is worth $2, and token B is worth $4, the pair price will be 2.0.\n    //   Note that the price is computed *including* the tokens decimals. This means that the pair price of a Pool with\n    //   DAI and USDC will be close to 1.0, despite DAI having 18 decimals and USDC 6.\n    //\n    // - BPT_PRICE: the price of the Pool share token (BPT), in units of the first token.\n    //   Note that the price is computed *including* the tokens decimals. This means that the BPT price of a Pool with\n    //   USDC in which BPT is worth $5 will be 5.0, despite the BPT having 18 decimals and USDC 6.\n    //\n    // - INVARIANT: the value of the Pool's invariant, which serves as a measure of its liquidity.\n    enum Variable { PAIR_PRICE, BPT_PRICE, INVARIANT }\n\n    /**\n     * @dev Returns the time average weighted price corresponding to each of `queries`. Prices are represented as 18\n     * decimal fixed point values.\n     */\n    function getTimeWeightedAverage(OracleAverageQuery[] memory queries)\n        external\n        view\n        returns (uint256[] memory results);\n\n    /**\n     * @dev Returns latest sample of `variable`. Prices are represented as 18 decimal fixed point values.\n     */\n    function getLatest(Variable variable) external view returns (uint256);\n\n    /**\n     * @dev Information for a Time Weighted Average query.\n     *\n     * Each query computes the average over a window of duration `secs` seconds that ended `ago` seconds ago. For\n     * example, the average over the past 30 minutes is computed by settings secs to 1800 and ago to 0. If secs is 1800\n     * and ago is 1800 as well, the average between 60 and 30 minutes ago is computed instead.\n     */\n    struct OracleAverageQuery {\n        Variable variable;\n        uint256 secs;\n        uint256 ago;\n    }\n\n    /**\n     * @dev Returns largest time window that can be safely queried, where 'safely' means the Oracle is guaranteed to be\n     * able to produce a result and not revert.\n     *\n     * If a query has a non-zero `ago` value, then `secs + ago` (the oldest point in time) must be smaller than this\n     * value for 'safe' queries.\n     */\n    function getLargestSafeQueryWindow() external view returns (uint256);\n\n    /**\n     * @dev Returns the accumulators corresponding to each of `queries`.\n     */\n    function getPastAccumulators(OracleAccumulatorQuery[] memory queries)\n        external\n        view\n        returns (int256[] memory results);\n\n    /**\n     * @dev Information for an Accumulator query.\n     *\n     * Each query estimates the accumulator at a time `ago` seconds ago.\n     */\n    struct OracleAccumulatorQuery {\n        Variable variable;\n        uint256 ago;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\n// solhint-disable\n\n/**\n * @dev Reverts if `condition` is false, with a revert reason containing `errorCode`. Only codes up to 999 are\n * supported.\n */\nfunction _require(bool condition, uint256 errorCode) pure {\n    if (!condition) _revert(errorCode);\n}\n\n/**\n * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported.\n */\nfunction _revert(uint256 errorCode) pure {\n    // We're going to dynamically create a revert string based on the error code, with the following format:\n    // 'BAL#{errorCode}'\n    // where the code is left-padded with zeroes to three digits (so they range from 000 to 999).\n    //\n    // We don't have revert strings embedded in the contract to save bytecode size: it takes much less space to store a\n    // number (8 to 16 bits) than the individual string characters.\n    //\n    // The dynamic string creation algorithm that follows could be implemented in Solidity, but assembly allows for a\n    // much denser implementation, again saving bytecode size. Given this function unconditionally reverts, this is a\n    // safe place to rely on it without worrying about how its usage might affect e.g. memory contents.\n    assembly {\n        // First, we need to compute the ASCII representation of the error code. We assume that it is in the 0-999\n        // range, so we only need to convert three digits. To convert the digits to ASCII, we add 0x30, the value for\n        // the '0' character.\n\n        let units := add(mod(errorCode, 10), 0x30)\n\n        errorCode := div(errorCode, 10)\n        let tenths := add(mod(errorCode, 10), 0x30)\n\n        errorCode := div(errorCode, 10)\n        let hundreds := add(mod(errorCode, 10), 0x30)\n\n        // With the individual characters, we can now construct the full string. The \"BAL#\" part is a known constant\n        // (0x42414c23): we simply shift this by 24 (to provide space for the 3 bytes of the error code), and add the\n        // characters to it, each shifted by a multiple of 8.\n        // The revert reason is then shifted left by 200 bits (256 minus the length of the string, 7 characters * 8 bits\n        // per character = 56) to locate it in the most significant part of the 256 slot (the beginning of a byte\n        // array).\n\n        let revertReason := shl(200, add(0x42414c23000000, add(add(units, shl(8, tenths)), shl(16, hundreds))))\n\n        // We can now encode the reason in memory, which can be safely overwritten as we're about to revert. The encoded\n        // message will have the following layout:\n        // [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ]\n\n        // The Solidity revert reason identifier is 0x08c739a0, the function selector of the Error(string) function. We\n        // also write zeroes to the next 28 bytes of memory, but those are about to be overwritten.\n        mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n        // Next is the offset to the location of the string, which will be placed immediately after (20 bytes away).\n        mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)\n        // The string length is fixed: 7 characters.\n        mstore(0x24, 7)\n        // Finally, the string itself is stored.\n        mstore(0x44, revertReason)\n\n        // Even if the string is only 7 bytes long, we need to return a full 32 byte slot containing it. The length of\n        // the encoded message is therefore 4 + 32 + 32 + 32 = 100.\n        revert(0, 100)\n    }\n}\n\nlibrary Errors {\n    // Math\n    uint256 internal constant ADD_OVERFLOW = 0;\n    uint256 internal constant SUB_OVERFLOW = 1;\n    uint256 internal constant SUB_UNDERFLOW = 2;\n    uint256 internal constant MUL_OVERFLOW = 3;\n    uint256 internal constant ZERO_DIVISION = 4;\n    uint256 internal constant DIV_INTERNAL = 5;\n    uint256 internal constant X_OUT_OF_BOUNDS = 6;\n    uint256 internal constant Y_OUT_OF_BOUNDS = 7;\n    uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8;\n    uint256 internal constant INVALID_EXPONENT = 9;\n\n    // Input\n    uint256 internal constant OUT_OF_BOUNDS = 100;\n    uint256 internal constant UNSORTED_ARRAY = 101;\n    uint256 internal constant UNSORTED_TOKENS = 102;\n    uint256 internal constant INPUT_LENGTH_MISMATCH = 103;\n    uint256 internal constant ZERO_TOKEN = 104;\n\n    // Shared pools\n    uint256 internal constant MIN_TOKENS = 200;\n    uint256 internal constant MAX_TOKENS = 201;\n    uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202;\n    uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203;\n    uint256 internal constant MINIMUM_BPT = 204;\n    uint256 internal constant CALLER_NOT_VAULT = 205;\n    uint256 internal constant UNINITIALIZED = 206;\n    uint256 internal constant BPT_IN_MAX_AMOUNT = 207;\n    uint256 internal constant BPT_OUT_MIN_AMOUNT = 208;\n    uint256 internal constant EXPIRED_PERMIT = 209;\n    uint256 internal constant NOT_TWO_TOKENS = 210;\n\n    // Pools\n    uint256 internal constant MIN_AMP = 300;\n    uint256 internal constant MAX_AMP = 301;\n    uint256 internal constant MIN_WEIGHT = 302;\n    uint256 internal constant MAX_STABLE_TOKENS = 303;\n    uint256 internal constant MAX_IN_RATIO = 304;\n    uint256 internal constant MAX_OUT_RATIO = 305;\n    uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306;\n    uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307;\n    uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308;\n    uint256 internal constant INVALID_TOKEN = 309;\n    uint256 internal constant UNHANDLED_JOIN_KIND = 310;\n    uint256 internal constant ZERO_INVARIANT = 311;\n    uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312;\n    uint256 internal constant ORACLE_NOT_INITIALIZED = 313;\n    uint256 internal constant ORACLE_QUERY_TOO_OLD = 314;\n    uint256 internal constant ORACLE_INVALID_INDEX = 315;\n    uint256 internal constant ORACLE_BAD_SECS = 316;\n    uint256 internal constant AMP_END_TIME_TOO_CLOSE = 317;\n    uint256 internal constant AMP_ONGOING_UPDATE = 318;\n    uint256 internal constant AMP_RATE_TOO_HIGH = 319;\n    uint256 internal constant AMP_NO_ONGOING_UPDATE = 320;\n    uint256 internal constant STABLE_INVARIANT_DIDNT_CONVERGE = 321;\n    uint256 internal constant STABLE_GET_BALANCE_DIDNT_CONVERGE = 322;\n    uint256 internal constant RELAYER_NOT_CONTRACT = 323;\n    uint256 internal constant BASE_POOL_RELAYER_NOT_CALLED = 324;\n    uint256 internal constant REBALANCING_RELAYER_REENTERED = 325;\n    uint256 internal constant GRADUAL_UPDATE_TIME_TRAVEL = 326;\n    uint256 internal constant SWAPS_DISABLED = 327;\n    uint256 internal constant CALLER_IS_NOT_LBP_OWNER = 328;\n    uint256 internal constant PRICE_RATE_OVERFLOW = 329;\n    uint256 internal constant INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED = 330;\n    uint256 internal constant WEIGHT_CHANGE_TOO_FAST = 331;\n    uint256 internal constant LOWER_GREATER_THAN_UPPER_TARGET = 332;\n    uint256 internal constant UPPER_TARGET_TOO_HIGH = 333;\n    uint256 internal constant UNHANDLED_BY_LINEAR_POOL = 334;\n    uint256 internal constant OUT_OF_TARGET_RANGE = 335;\n\n    // Lib\n    uint256 internal constant REENTRANCY = 400;\n    uint256 internal constant SENDER_NOT_ALLOWED = 401;\n    uint256 internal constant PAUSED = 402;\n    uint256 internal constant PAUSE_WINDOW_EXPIRED = 403;\n    uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404;\n    uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405;\n    uint256 internal constant INSUFFICIENT_BALANCE = 406;\n    uint256 internal constant INSUFFICIENT_ALLOWANCE = 407;\n    uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408;\n    uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409;\n    uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410;\n    uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411;\n    uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412;\n    uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413;\n    uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414;\n    uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415;\n    uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416;\n    uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417;\n    uint256 internal constant SAFE_ERC20_CALL_FAILED = 418;\n    uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419;\n    uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420;\n    uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421;\n    uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422;\n    uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423;\n    uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424;\n    uint256 internal constant BUFFER_PERIOD_EXPIRED = 425;\n    uint256 internal constant CALLER_IS_NOT_OWNER = 426;\n    uint256 internal constant NEW_OWNER_IS_ZERO = 427;\n    uint256 internal constant CODE_DEPLOYMENT_FAILED = 428;\n    uint256 internal constant CALL_TO_NON_CONTRACT = 429;\n    uint256 internal constant LOW_LEVEL_CALL_FAILED = 430;\n\n    // Vault\n    uint256 internal constant INVALID_POOL_ID = 500;\n    uint256 internal constant CALLER_NOT_POOL = 501;\n    uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502;\n    uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503;\n    uint256 internal constant INVALID_SIGNATURE = 504;\n    uint256 internal constant EXIT_BELOW_MIN = 505;\n    uint256 internal constant JOIN_ABOVE_MAX = 506;\n    uint256 internal constant SWAP_LIMIT = 507;\n    uint256 internal constant SWAP_DEADLINE = 508;\n    uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509;\n    uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510;\n    uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511;\n    uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512;\n    uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513;\n    uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514;\n    uint256 internal constant INVALID_POST_LOAN_BALANCE = 515;\n    uint256 internal constant INSUFFICIENT_ETH = 516;\n    uint256 internal constant UNALLOCATED_ETH = 517;\n    uint256 internal constant ETH_TRANSFER = 518;\n    uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519;\n    uint256 internal constant TOKENS_MISMATCH = 520;\n    uint256 internal constant TOKEN_NOT_REGISTERED = 521;\n    uint256 internal constant TOKEN_ALREADY_REGISTERED = 522;\n    uint256 internal constant TOKENS_ALREADY_SET = 523;\n    uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524;\n    uint256 internal constant NONZERO_TOKEN_BALANCE = 525;\n    uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526;\n    uint256 internal constant POOL_NO_TOKENS = 527;\n    uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528;\n\n    // Fees\n    uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600;\n    uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601;\n    uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602;\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/WordCodec.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in\n * a single storage slot, saving gas by performing less storage accesses.\n *\n * Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two\n * 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128.\n */\nlibrary WordCodec {\n    // Masks are values with the least significant N bits set. They can be used to extract an encoded value from a word,\n    // or to insert a new one replacing the old.\n    uint256 private constant _MASK_1 = 2**(1) - 1;\n    uint256 private constant _MASK_5 = 2**(5) - 1;\n    uint256 private constant _MASK_7 = 2**(7) - 1;\n    uint256 private constant _MASK_10 = 2**(10) - 1;\n    uint256 private constant _MASK_16 = 2**(16) - 1;\n    uint256 private constant _MASK_22 = 2**(22) - 1;\n    uint256 private constant _MASK_31 = 2**(31) - 1;\n    uint256 private constant _MASK_32 = 2**(32) - 1;\n    uint256 private constant _MASK_53 = 2**(53) - 1;\n    uint256 private constant _MASK_64 = 2**(64) - 1;\n    uint256 private constant _MASK_128 = 2**(128) - 1;\n    uint256 private constant _MASK_192 = 2**(192) - 1;\n\n    // Largest positive values that can be represented as N bits signed integers.\n    int256 private constant _MAX_INT_22 = 2**(21) - 1;\n    int256 private constant _MAX_INT_53 = 2**(52) - 1;\n\n    // In-place insertion\n\n    /**\n     * @dev Inserts a boolean value shifted by an offset into a 256 bit word, replacing the old value. Returns the new\n     * word.\n     */\n    function insertBool(\n        bytes32 word,\n        bool value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_1 << offset));\n        return clearedWord | bytes32(uint256(value ? 1 : 0) << offset);\n    }\n\n    // Unsigned\n\n    /**\n     * @dev Inserts a 5 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` only uses its least significant 5 bits, otherwise it may overwrite sibling bytes.\n     */\n    function insertUint5(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_5 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    /**\n     * @dev Inserts a 7 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` only uses its least significant 7 bits, otherwise it may overwrite sibling bytes.\n     */\n    function insertUint7(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_7 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    /**\n     * @dev Inserts a 10 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` only uses its least significant 10 bits, otherwise it may overwrite sibling bytes.\n     */\n    function insertUint10(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_10 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    /**\n     * @dev Inserts a 16 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value.\n     * Returns the new word.\n     *\n     * Assumes `value` only uses its least significant 16 bits, otherwise it may overwrite sibling bytes.\n     */\n    function insertUint16(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_16 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    /**\n     * @dev Inserts a 31 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` can be represented using 31 bits.\n     */\n    function insertUint31(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_31 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    /**\n     * @dev Inserts a 32 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` only uses its least significant 32 bits, otherwise it may overwrite sibling bytes.\n     */\n    function insertUint32(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_32 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    /**\n     * @dev Inserts a 64 bit unsigned integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` only uses its least significant 64 bits, otherwise it may overwrite sibling bytes.\n     */\n    function insertUint64(\n        bytes32 word,\n        uint256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_64 << offset));\n        return clearedWord | bytes32(value << offset);\n    }\n\n    // Signed\n\n    /**\n     * @dev Inserts a 22 bits signed integer shifted by an offset into a 256 bit word, replacing the old value. Returns\n     * the new word.\n     *\n     * Assumes `value` can be represented using 22 bits.\n     */\n    function insertInt22(\n        bytes32 word,\n        int256 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_22 << offset));\n        // Integer values need masking to remove the upper bits of negative values.\n        return clearedWord | bytes32((uint256(value) & _MASK_22) << offset);\n    }\n\n    // Bytes\n\n    /**\n     * @dev Inserts 192 bit shifted by an offset into a 256 bit word, replacing the old value. Returns the new word.\n     *\n     * Assumes `value` can be represented using 192 bits.\n     */\n    function insertBits192(\n        bytes32 word,\n        bytes32 value,\n        uint256 offset\n    ) internal pure returns (bytes32) {\n        bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_192 << offset));\n        return clearedWord | bytes32((uint256(value) & _MASK_192) << offset);\n    }\n\n    // Encoding\n\n    // Unsigned\n\n    /**\n     * @dev Encodes an unsigned integer shifted by an offset. This performs no size checks: it is up to the caller to\n     * ensure that the values are bounded.\n     *\n     * The return value can be logically ORed with other encoded values to form a 256 bit word.\n     */\n    function encodeUint(uint256 value, uint256 offset) internal pure returns (bytes32) {\n        return bytes32(value << offset);\n    }\n\n    // Signed\n\n    /**\n     * @dev Encodes a 22 bits signed integer shifted by an offset.\n     *\n     * The return value can be logically ORed with other encoded values to form a 256 bit word.\n     */\n    function encodeInt22(int256 value, uint256 offset) internal pure returns (bytes32) {\n        // Integer values need masking to remove the upper bits of negative values.\n        return bytes32((uint256(value) & _MASK_22) << offset);\n    }\n\n    /**\n     * @dev Encodes a 53 bits signed integer shifted by an offset.\n     *\n     * The return value can be logically ORed with other encoded values to form a 256 bit word.\n     */\n    function encodeInt53(int256 value, uint256 offset) internal pure returns (bytes32) {\n        // Integer values need masking to remove the upper bits of negative values.\n        return bytes32((uint256(value) & _MASK_53) << offset);\n    }\n\n    // Decoding\n\n    /**\n     * @dev Decodes and returns a boolean shifted by an offset from a 256 bit word.\n     */\n    function decodeBool(bytes32 word, uint256 offset) internal pure returns (bool) {\n        return (uint256(word >> offset) & _MASK_1) == 1;\n    }\n\n    // Unsigned\n\n    /**\n     * @dev Decodes and returns a 5 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint5(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_5;\n    }\n\n    /**\n     * @dev Decodes and returns a 7 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint7(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_7;\n    }\n\n    /**\n     * @dev Decodes and returns a 10 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint10(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_10;\n    }\n\n    /**\n     * @dev Decodes and returns a 16 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint16(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_16;\n    }\n\n    /**\n     * @dev Decodes and returns a 31 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint31(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_31;\n    }\n\n    /**\n     * @dev Decodes and returns a 32 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint32(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_32;\n    }\n\n    /**\n     * @dev Decodes and returns a 64 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint64(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_64;\n    }\n\n    /**\n     * @dev Decodes and returns a 128 bit unsigned integer shifted by an offset from a 256 bit word.\n     */\n    function decodeUint128(bytes32 word, uint256 offset) internal pure returns (uint256) {\n        return uint256(word >> offset) & _MASK_128;\n    }\n\n    // Signed\n\n    /**\n     * @dev Decodes and returns a 22 bits signed integer shifted by an offset from a 256 bit word.\n     */\n    function decodeInt22(bytes32 word, uint256 offset) internal pure returns (int256) {\n        int256 value = int256(uint256(word >> offset) & _MASK_22);\n        // In case the decoded value is greater than the max positive integer that can be represented with 22 bits,\n        // we know it was originally a negative integer. Therefore, we mask it to restore the sign in the 256 bit\n        // representation.\n        return value > _MAX_INT_22 ? (value | int256(~_MASK_22)) : value;\n    }\n\n    /**\n     * @dev Decodes and returns a 53 bits signed integer shifted by an offset from a 256 bit word.\n     */\n    function decodeInt53(bytes32 word, uint256 offset) internal pure returns (int256) {\n        int256 value = int256(uint256(word >> offset) & _MASK_53);\n        // In case the decoded value is greater than the max positive integer that can be represented with 53 bits,\n        // we know it was originally a negative integer. Therefore, we mask it to restore the sign in the 256 bit\n        // representation.\n\n        return value > _MAX_INT_53 ? (value | int256(~_MASK_53)) : value;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/math/LogExpMath.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated\n// documentation files (the “Software”), to deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the\n// Software.\n\n// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE\n// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/* solhint-disable */\n\n/**\n * @dev Exponentiation and logarithm functions for 18 decimal fixed point numbers (both base and exponent/argument).\n *\n * Exponentiation and logarithm with arbitrary bases (x^y and log_x(y)) are implemented by conversion to natural\n * exponentiation and logarithm (where the base is Euler's number).\n *\n * @author Fernando Martinelli - @fernandomartinelli\n * @author Sergio Yuhjtman - @sergioyuhjtman\n * @author Daniel Fernandez - @dmf7z\n */\nlibrary LogExpMath {\n    // All fixed point multiplications and divisions are inlined. This means we need to divide by ONE when multiplying\n    // two numbers, and multiply by ONE when dividing them.\n\n    // All arguments and return values are 18 decimal fixed point numbers.\n    int256 constant ONE_18 = 1e18;\n\n    // Internally, intermediate values are computed with higher precision as 20 decimal fixed point numbers, and in the\n    // case of ln36, 36 decimals.\n    int256 constant ONE_20 = 1e20;\n    int256 constant ONE_36 = 1e36;\n\n    // The domain of natural exponentiation is bound by the word size and number of decimals used.\n    //\n    // Because internally the result will be stored using 20 decimals, the largest possible result is\n    // (2^255 - 1) / 10^20, which makes the largest exponent ln((2^255 - 1) / 10^20) = 130.700829182905140221.\n    // The smallest possible result is 10^(-18), which makes largest negative argument\n    // ln(10^(-18)) = -41.446531673892822312.\n    // We use 130.0 and -41.0 to have some safety margin.\n    int256 constant MAX_NATURAL_EXPONENT = 130e18;\n    int256 constant MIN_NATURAL_EXPONENT = -41e18;\n\n    // Bounds for ln_36's argument. Both ln(0.9) and ln(1.1) can be represented with 36 decimal places in a fixed point\n    // 256 bit integer.\n    int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;\n    int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;\n\n    uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20);\n\n    // 18 decimal constants\n    int256 constant x0 = 128000000000000000000; // 2ˆ7\n    int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)\n    int256 constant x1 = 64000000000000000000; // 2ˆ6\n    int256 constant a1 = 6235149080811616882910000000; // eˆ(x1) (no decimals)\n\n    // 20 decimal constants\n    int256 constant x2 = 3200000000000000000000; // 2ˆ5\n    int256 constant a2 = 7896296018268069516100000000000000; // eˆ(x2)\n    int256 constant x3 = 1600000000000000000000; // 2ˆ4\n    int256 constant a3 = 888611052050787263676000000; // eˆ(x3)\n    int256 constant x4 = 800000000000000000000; // 2ˆ3\n    int256 constant a4 = 298095798704172827474000; // eˆ(x4)\n    int256 constant x5 = 400000000000000000000; // 2ˆ2\n    int256 constant a5 = 5459815003314423907810; // eˆ(x5)\n    int256 constant x6 = 200000000000000000000; // 2ˆ1\n    int256 constant a6 = 738905609893065022723; // eˆ(x6)\n    int256 constant x7 = 100000000000000000000; // 2ˆ0\n    int256 constant a7 = 271828182845904523536; // eˆ(x7)\n    int256 constant x8 = 50000000000000000000; // 2ˆ-1\n    int256 constant a8 = 164872127070012814685; // eˆ(x8)\n    int256 constant x9 = 25000000000000000000; // 2ˆ-2\n    int256 constant a9 = 128402541668774148407; // eˆ(x9)\n    int256 constant x10 = 12500000000000000000; // 2ˆ-3\n    int256 constant a10 = 113314845306682631683; // eˆ(x10)\n    int256 constant x11 = 6250000000000000000; // 2ˆ-4\n    int256 constant a11 = 106449445891785942956; // eˆ(x11)\n\n    /**\n     * @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent.\n     *\n     * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.\n     */\n    function pow(uint256 x, uint256 y) internal pure returns (uint256) {\n        if (y == 0) {\n            // We solve the 0^0 indetermination by making it equal one.\n            return uint256(ONE_18);\n        }\n\n        if (x == 0) {\n            return 0;\n        }\n\n        // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to\n        // arrive at that result. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means\n        // x^y = exp(y * ln(x)).\n\n        // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.\n        _require(x < 2**255, Errors.X_OUT_OF_BOUNDS);\n        int256 x_int256 = int256(x);\n\n        // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In\n        // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.\n\n        // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.\n        _require(y < MILD_EXPONENT_BOUND, Errors.Y_OUT_OF_BOUNDS);\n        int256 y_int256 = int256(y);\n\n        int256 logx_times_y;\n        if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {\n            int256 ln_36_x = _ln_36(x_int256);\n\n            // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just\n            // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal\n            // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the\n            // (downscaled) last 18 decimals.\n            logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18);\n        } else {\n            logx_times_y = _ln(x_int256) * y_int256;\n        }\n        logx_times_y /= ONE_18;\n\n        // Finally, we compute exp(y * ln(x)) to arrive at x^y\n        _require(\n            MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,\n            Errors.PRODUCT_OUT_OF_BOUNDS\n        );\n\n        return uint256(exp(logx_times_y));\n    }\n\n    /**\n     * @dev Natural exponentiation (e^x) with signed 18 decimal fixed point exponent.\n     *\n     * Reverts if `x` is smaller than MIN_NATURAL_EXPONENT, or larger than `MAX_NATURAL_EXPONENT`.\n     */\n    function exp(int256 x) internal pure returns (int256) {\n        _require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, Errors.INVALID_EXPONENT);\n\n        if (x < 0) {\n            // We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since it\n            // fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).\n            // Fixed point division requires multiplying by ONE_18.\n            return ((ONE_18 * ONE_18) / exp(-x));\n        }\n\n        // First, we use the fact that e^(x+y) = e^x * e^y to decompose x into a sum of powers of two, which we call x_n,\n        // where x_n == 2^(7 - n), and e^x_n = a_n has been precomputed. We choose the first x_n, x0, to equal 2^7\n        // because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the\n        // decomposition.\n        // At the end of this process we will have the product of all e^x_n = a_n that apply, and the remainder of this\n        // decomposition, which will be lower than the smallest x_n.\n        // exp(x) = k_0 * a_0 * k_1 * a_1 * ... + k_n * a_n * exp(remainder), where each k_n equals either 0 or 1.\n        // We mutate x by subtracting x_n, making it the remainder of the decomposition.\n\n        // The first two a_n (e^(2^7) and e^(2^6)) are too large if stored as 18 decimal numbers, and could cause\n        // intermediate overflows. Instead we store them as plain integers, with 0 decimals.\n        // Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in the\n        // decomposition.\n\n        // For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so deduct\n        // it and compute the accumulated product.\n\n        int256 firstAN;\n        if (x >= x0) {\n            x -= x0;\n            firstAN = a0;\n        } else if (x >= x1) {\n            x -= x1;\n            firstAN = a1;\n        } else {\n            firstAN = 1; // One with no decimal places\n        }\n\n        // We now transform x into a 20 decimal fixed point number, to have enhanced precision when computing the\n        // smaller terms.\n        x *= 100;\n\n        // `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed point\n        // one. Recall that fixed point multiplication requires dividing by ONE_20.\n        int256 product = ONE_20;\n\n        if (x >= x2) {\n            x -= x2;\n            product = (product * a2) / ONE_20;\n        }\n        if (x >= x3) {\n            x -= x3;\n            product = (product * a3) / ONE_20;\n        }\n        if (x >= x4) {\n            x -= x4;\n            product = (product * a4) / ONE_20;\n        }\n        if (x >= x5) {\n            x -= x5;\n            product = (product * a5) / ONE_20;\n        }\n        if (x >= x6) {\n            x -= x6;\n            product = (product * a6) / ONE_20;\n        }\n        if (x >= x7) {\n            x -= x7;\n            product = (product * a7) / ONE_20;\n        }\n        if (x >= x8) {\n            x -= x8;\n            product = (product * a8) / ONE_20;\n        }\n        if (x >= x9) {\n            x -= x9;\n            product = (product * a9) / ONE_20;\n        }\n\n        // x10 and x11 are unnecessary here since we have high enough precision already.\n\n        // Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor series\n        // expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).\n\n        int256 seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places.\n        int256 term; // Each term in the sum, where the nth term is (x^n / n!).\n\n        // The first term is simply x.\n        term = x;\n        seriesSum += term;\n\n        // Each term (x^n / n!) equals the previous one times x, divided by n. Since x is a fixed point number,\n        // multiplying by it requires dividing by ONE_20, but dividing by the non-fixed point n values does not.\n\n        term = ((term * x) / ONE_20) / 2;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 3;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 4;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 5;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 6;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 7;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 8;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 9;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 10;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 11;\n        seriesSum += term;\n\n        term = ((term * x) / ONE_20) / 12;\n        seriesSum += term;\n\n        // 12 Taylor terms are sufficient for 18 decimal precision.\n\n        // We now have the first a_n (with no decimals), and the product of all other a_n present, and the Taylor\n        // approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to multiply\n        // all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer multiplication),\n        // and then drop two digits to return an 18 decimal value.\n\n        return (((product * seriesSum) / ONE_20) * firstAN) / 100;\n    }\n\n    /**\n     * @dev Logarithm (log(arg, base), with signed 18 decimal fixed point base and argument.\n     */\n    function log(int256 arg, int256 base) internal pure returns (int256) {\n        // This performs a simple base change: log(arg, base) = ln(arg) / ln(base).\n\n        // Both logBase and logArg are computed as 36 decimal fixed point numbers, either by using ln_36, or by\n        // upscaling.\n\n        int256 logBase;\n        if (LN_36_LOWER_BOUND < base && base < LN_36_UPPER_BOUND) {\n            logBase = _ln_36(base);\n        } else {\n            logBase = _ln(base) * ONE_18;\n        }\n\n        int256 logArg;\n        if (LN_36_LOWER_BOUND < arg && arg < LN_36_UPPER_BOUND) {\n            logArg = _ln_36(arg);\n        } else {\n            logArg = _ln(arg) * ONE_18;\n        }\n\n        // When dividing, we multiply by ONE_18 to arrive at a result with 18 decimal places\n        return (logArg * ONE_18) / logBase;\n    }\n\n    /**\n     * @dev Natural logarithm (ln(a)) with signed 18 decimal fixed point argument.\n     */\n    function ln(int256 a) internal pure returns (int256) {\n        // The real natural logarithm is not defined for negative numbers or zero.\n        _require(a > 0, Errors.OUT_OF_BOUNDS);\n        if (LN_36_LOWER_BOUND < a && a < LN_36_UPPER_BOUND) {\n            return _ln_36(a) / ONE_18;\n        } else {\n            return _ln(a);\n        }\n    }\n\n    /**\n     * @dev Internal natural logarithm (ln(a)) with signed 18 decimal fixed point argument.\n     */\n    function _ln(int256 a) private pure returns (int256) {\n        if (a < ONE_18) {\n            // Since ln(a^k) = k * ln(a), we can compute ln(a) as ln(a) = ln((1/a)^(-1)) = - ln((1/a)). If a is less\n            // than one, 1/a will be greater than one, and this if statement will not be entered in the recursive call.\n            // Fixed point division requires multiplying by ONE_18.\n            return (-_ln((ONE_18 * ONE_18) / a));\n        }\n\n        // First, we use the fact that ln^(a * b) = ln(a) + ln(b) to decompose ln(a) into a sum of powers of two, which\n        // we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n (that is,\n        // ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers cannot\n        // be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.\n        // At the end of this process we will have the sum of all x_n = ln(a_n) that apply, and the remainder of this\n        // decomposition, which will be lower than the smallest a_n.\n        // ln(a) = k_0 * x_0 + k_1 * x_1 + ... + k_n * x_n + ln(remainder), where each k_n equals either 0 or 1.\n        // We mutate a by subtracting a_n, making it the remainder of the decomposition.\n\n        // For reasons related to how `exp` works, the first two a_n (e^(2^7) and e^(2^6)) are not stored as fixed point\n        // numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply them by\n        // ONE_18 to convert them to fixed point.\n        // For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so divide\n        // by it and compute the accumulated sum.\n\n        int256 sum = 0;\n        if (a >= a0 * ONE_18) {\n            a /= a0; // Integer, not fixed point division\n            sum += x0;\n        }\n\n        if (a >= a1 * ONE_18) {\n            a /= a1; // Integer, not fixed point division\n            sum += x1;\n        }\n\n        // All other a_n and x_n are stored as 20 digit fixed point numbers, so we convert the sum and a to this format.\n        sum *= 100;\n        a *= 100;\n\n        // Because further a_n are  20 digit fixed point numbers, we multiply by ONE_20 when dividing by them.\n\n        if (a >= a2) {\n            a = (a * ONE_20) / a2;\n            sum += x2;\n        }\n\n        if (a >= a3) {\n            a = (a * ONE_20) / a3;\n            sum += x3;\n        }\n\n        if (a >= a4) {\n            a = (a * ONE_20) / a4;\n            sum += x4;\n        }\n\n        if (a >= a5) {\n            a = (a * ONE_20) / a5;\n            sum += x5;\n        }\n\n        if (a >= a6) {\n            a = (a * ONE_20) / a6;\n            sum += x6;\n        }\n\n        if (a >= a7) {\n            a = (a * ONE_20) / a7;\n            sum += x7;\n        }\n\n        if (a >= a8) {\n            a = (a * ONE_20) / a8;\n            sum += x8;\n        }\n\n        if (a >= a9) {\n            a = (a * ONE_20) / a9;\n            sum += x9;\n        }\n\n        if (a >= a10) {\n            a = (a * ONE_20) / a10;\n            sum += x10;\n        }\n\n        if (a >= a11) {\n            a = (a * ONE_20) / a11;\n            sum += x11;\n        }\n\n        // a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor series\n        // that converges rapidly for values of `a` close to one - the same one used in ln_36.\n        // Let z = (a - 1) / (a + 1).\n        // ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))\n\n        // Recall that 20 digit fixed point division requires multiplying by ONE_20, and multiplication requires\n        // division by ONE_20.\n        int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20);\n        int256 z_squared = (z * z) / ONE_20;\n\n        // num is the numerator of the series: the z^(2 * n + 1) term\n        int256 num = z;\n\n        // seriesSum holds the accumulated sum of each term in the series, starting with the initial z\n        int256 seriesSum = num;\n\n        // In each step, the numerator is multiplied by z^2\n        num = (num * z_squared) / ONE_20;\n        seriesSum += num / 3;\n\n        num = (num * z_squared) / ONE_20;\n        seriesSum += num / 5;\n\n        num = (num * z_squared) / ONE_20;\n        seriesSum += num / 7;\n\n        num = (num * z_squared) / ONE_20;\n        seriesSum += num / 9;\n\n        num = (num * z_squared) / ONE_20;\n        seriesSum += num / 11;\n\n        // 6 Taylor terms are sufficient for 36 decimal precision.\n\n        // Finally, we multiply by 2 (non fixed point) to compute ln(remainder)\n        seriesSum *= 2;\n\n        // We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder (both\n        // with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18 decimal\n        // value.\n\n        return (sum + seriesSum) / 100;\n    }\n\n    /**\n     * @dev Intrnal high precision (36 decimal places) natural logarithm (ln(x)) with signed 18 decimal fixed point argument,\n     * for x close to one.\n     *\n     * Should only be used if x is between LN_36_LOWER_BOUND and LN_36_UPPER_BOUND.\n     */\n    function _ln_36(int256 x) private pure returns (int256) {\n        // Since ln(1) = 0, a value of x close to one will yield a very small result, which makes using 36 digits\n        // worthwhile.\n\n        // First, we transform x to a 36 digit fixed point value.\n        x *= ONE_18;\n\n        // We will use the following Taylor expansion, which converges very rapidly. Let z = (x - 1) / (x + 1).\n        // ln(x) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))\n\n        // Recall that 36 digit fixed point division requires multiplying by ONE_36, and multiplication requires\n        // division by ONE_36.\n        int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36);\n        int256 z_squared = (z * z) / ONE_36;\n\n        // num is the numerator of the series: the z^(2 * n + 1) term\n        int256 num = z;\n\n        // seriesSum holds the accumulated sum of each term in the series, starting with the initial z\n        int256 seriesSum = num;\n\n        // In each step, the numerator is multiplied by z^2\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 3;\n\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 5;\n\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 7;\n\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 9;\n\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 11;\n\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 13;\n\n        num = (num * z_squared) / ONE_36;\n        seriesSum += num / 15;\n\n        // 8 Taylor terms are sufficient for 36 decimal precision.\n\n        // All that remains is multiplying by 2 (non fixed point).\n        return seriesSum * 2;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ERC20Permit.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"./ERC20.sol\";\nimport \"./IERC20Permit.sol\";\nimport \"./EIP712.sol\";\n\n/**\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * _Available since v3.4._\n */\nabstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {\n    mapping(address => uint256) private _nonces;\n\n    // solhint-disable-next-line var-name-mixedcase\n    bytes32 private immutable _PERMIT_TYPEHASH =\n        keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n\n    /**\n     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n     *\n     * It's a good idea to use the same `name` that is defined as the ERC20 token name.\n     */\n    constructor(string memory name) EIP712(name, \"1\") {}\n\n    /**\n     * @dev See {IERC20Permit-permit}.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual override {\n        // solhint-disable-next-line not-rely-on-time\n        _require(block.timestamp <= deadline, Errors.EXPIRED_PERMIT);\n\n        uint256 nonce = _nonces[owner];\n        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, nonce, deadline));\n\n        bytes32 hash = _hashTypedDataV4(structHash);\n\n        address signer = ecrecover(hash, v, r, s);\n        _require((signer != address(0)) && (signer == owner), Errors.INVALID_SIGNATURE);\n\n        _nonces[owner] = nonce + 1;\n        _approve(owner, spender, value);\n    }\n\n    /**\n     * @dev See {IERC20Permit-nonces}.\n     */\n    function nonces(address owner) public view override returns (uint256) {\n        return _nonces[owner];\n    }\n\n    /**\n     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeMath.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        _require(c >= a, Errors.ADD_OVERFLOW);\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, Errors.SUB_OVERFLOW);\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, uint256 errorCode) internal pure returns (uint256) {\n        _require(b <= a, errorCode);\n        uint256 c = a - b;\n\n        return c;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20Permit.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,\n     * given `owner`'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EIP712.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712 {\n    /* solhint-disable var-name-mixedcase */\n    bytes32 private immutable _HASHED_NAME;\n    bytes32 private immutable _HASHED_VERSION;\n    bytes32 private immutable _TYPE_HASH;\n\n    /* solhint-enable var-name-mixedcase */\n\n    /**\n     * @dev Initializes the domain separator and parameter caches.\n     *\n     * The meaning of `name` and `version` is specified in\n     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n     *\n     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n     * - `version`: the current major version of the signing domain.\n     *\n     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n     * contract upgrade].\n     */\n    constructor(string memory name, string memory version) {\n        _HASHED_NAME = keccak256(bytes(name));\n        _HASHED_VERSION = keccak256(bytes(version));\n        _TYPE_HASH = keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\");\n    }\n\n    /**\n     * @dev Returns the domain separator for the current chain.\n     */\n    function _domainSeparatorV4() internal view virtual returns (bytes32) {\n        return keccak256(abi.encode(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION, _getChainId(), address(this)));\n    }\n\n    /**\n     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n     * function returns the hash of the fully encoded EIP712 message for this domain.\n     *\n     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n     *\n     * ```solidity\n     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n     *     keccak256(\"Mail(address to,string contents)\"),\n     *     mailTo,\n     *     keccak256(bytes(mailContents))\n     * )));\n     * address signer = ECDSA.recover(digest, signature);\n     * ```\n     */\n    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", _domainSeparatorV4(), structHash));\n    }\n\n    function _getChainId() private view returns (uint256 chainId) {\n        // Silence state mutability warning without generating bytecode.\n        // See https://github.com/ethereum/solidity/issues/10090#issuecomment-741789128 and\n        // https://github.com/ethereum/solidity/issues/2691\n        this;\n\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            chainId := chainid()\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IAuthorizer.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\ninterface IAuthorizer {\n    /**\n     * @dev Returns true if `account` can perform the action described by `actionId` in the contract `where`.\n     */\n    function canPerform(\n        bytes32 actionId,\n        address account,\n        address where\n    ) external view returns (bool);\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/misc/IWETH.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"../openzeppelin/IERC20.sol\";\n\n/**\n * @dev Interface for WETH9.\n * See https://github.com/gnosis/canonical-weth/blob/0dd1ea3e295eef916d0c6223ec63141137d22d67/contracts/WETH9.sol\n */\ninterface IWETH is IERC20 {\n    function deposit() external payable;\n\n    function withdraw(uint256 amount) external;\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IProtocolFeesCollector.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\nimport \"./IVault.sol\";\nimport \"./IAuthorizer.sol\";\n\ninterface IProtocolFeesCollector {\n    event SwapFeePercentageChanged(uint256 newSwapFeePercentage);\n    event FlashLoanFeePercentageChanged(uint256 newFlashLoanFeePercentage);\n\n    function withdrawCollectedFees(\n        IERC20[] calldata tokens,\n        uint256[] calldata amounts,\n        address recipient\n    ) external;\n\n    function setSwapFeePercentage(uint256 newSwapFeePercentage) external;\n\n    function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external;\n\n    function getSwapFeePercentage() external view returns (uint256);\n\n    function getFlashLoanFeePercentage() external view returns (uint256);\n\n    function getCollectedFeeAmounts(IERC20[] memory tokens) external view returns (uint256[] memory feeAmounts);\n\n    function getAuthorizer() external view returns (IAuthorizer);\n\n    function vault() external view returns (IVault);\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/ITemporarilyPausable.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface for the TemporarilyPausable helper.\n */\ninterface ITemporarilyPausable {\n    /**\n     * @dev Emitted every time the pause state changes by `_setPaused`.\n     */\n    event PausedStateChanged(bool paused);\n\n    /**\n     * @dev Returns the current paused state.\n     */\n    function getPausedState()\n        external\n        view\n        returns (\n            bool paused,\n            uint256 pauseWindowEndTime,\n            uint256 bufferPeriodEndTime\n        );\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/ISignaturesValidator.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\n/**\n * @dev Interface for the SignatureValidator helper, used to support meta-transactions.\n */\ninterface ISignaturesValidator {\n    /**\n     * @dev Returns the EIP712 domain separator.\n     */\n    function getDomainSeparator() external view returns (bytes32);\n\n    /**\n     * @dev Returns the next nonce used by an address to sign messages.\n     */\n    function getNextNonce(address user) external view returns (uint256);\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IFlashLoanRecipient.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\n// Inspired by Aave Protocol's IFlashLoanReceiver.\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\ninterface IFlashLoanRecipient {\n    /**\n     * @dev When `flashLoan` is called on the Vault, it invokes the `receiveFlashLoan` hook on the recipient.\n     *\n     * At the time of the call, the Vault will have transferred `amounts` for `tokens` to the recipient. Before this\n     * call returns, the recipient must have transferred `amounts` plus `feeAmounts` for each token back to the\n     * Vault, or else the entire flash loan will revert.\n     *\n     * `userData` is the same value passed in the `IVault.flashLoan` call.\n     */\n    function receiveFlashLoan(\n        IERC20[] memory tokens,\n        uint256[] memory amounts,\n        uint256[] memory feeAmounts,\n        bytes memory userData\n    ) external;\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IAsset.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\n/**\n * @dev This is an empty interface used to represent either ERC20-conforming token contracts or ETH (using the zero\n * address sentinel value). We're just relying on the fact that `interface` can be used to declare new address-like\n * types.\n *\n * This concept is unrelated to a Pool's Asset Managers.\n */\ninterface IAsset {\n    // solhint-disable-previous-line no-empty-blocks\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IBasePool.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"./IVault.sol\";\nimport \"./IPoolSwapStructs.sol\";\n\n/**\n * @dev Interface for adding and removing liquidity that all Pool contracts should implement. Note that this is not\n * the complete Pool contract interface, as it is missing the swap hooks. Pool contracts should also inherit from\n * either IGeneralPool or IMinimalSwapInfoPool\n */\ninterface IBasePool is IPoolSwapStructs {\n    /**\n     * @dev Called by the Vault when a user calls `IVault.joinPool` to add liquidity to this Pool. Returns how many of\n     * each registered token the user should provide, as well as the amount of protocol fees the Pool owes to the Vault.\n     * The Vault will then take tokens from `sender` and add them to the Pool's balances, as well as collect\n     * the reported amount in protocol fees, which the pool should calculate based on `protocolSwapFeePercentage`.\n     *\n     * Protocol fees are reported and charged on join events so that the Pool is free of debt whenever new users join.\n     *\n     * `sender` is the account performing the join (from which tokens will be withdrawn), and `recipient` is the account\n     * designated to receive any benefits (typically pool shares). `balances` contains the total balances\n     * for each token the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return.\n     *\n     * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total\n     * balance.\n     *\n     * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of\n     * join (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.)\n     *\n     * Contracts implementing this function should check that the caller is indeed the Vault before performing any\n     * state-changing operations, such as minting pool shares.\n     */\n    function onJoinPool(\n        bytes32 poolId,\n        address sender,\n        address recipient,\n        uint256[] memory balances,\n        uint256 lastChangeBlock,\n        uint256 protocolSwapFeePercentage,\n        bytes memory userData\n    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);\n\n    /**\n     * @dev Called by the Vault when a user calls `IVault.exitPool` to remove liquidity from this Pool. Returns how many\n     * tokens the Vault should deduct from the Pool's balances, as well as the amount of protocol fees the Pool owes\n     * to the Vault. The Vault will then take tokens from the Pool's balances and send them to `recipient`,\n     * as well as collect the reported amount in protocol fees, which the Pool should calculate based on\n     * `protocolSwapFeePercentage`.\n     *\n     * Protocol fees are charged on exit events to guarantee that users exiting the Pool have paid their share.\n     *\n     * `sender` is the account performing the exit (typically the pool shareholder), and `recipient` is the account\n     * to which the Vault will send the proceeds. `balances` contains the total token balances for each token\n     * the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return.\n     *\n     * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total\n     * balance.\n     *\n     * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of\n     * exit (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.)\n     *\n     * Contracts implementing this function should check that the caller is indeed the Vault before performing any\n     * state-changing operations, such as burning pool shares.\n     */\n    function onExitPool(\n        bytes32 poolId,\n        address sender,\n        address recipient,\n        uint256[] memory balances,\n        uint256 lastChangeBlock,\n        uint256 protocolSwapFeePercentage,\n        bytes memory userData\n    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);\n\n    function getPoolId() external view returns (bytes32);\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IPoolSwapStructs.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\nimport \"./IVault.sol\";\n\ninterface IPoolSwapStructs {\n    // This is not really an interface - it just defines common structs used by other interfaces: IGeneralPool and\n    // IMinimalSwapInfoPool.\n    //\n    // This data structure represents a request for a token swap, where `kind` indicates the swap type ('given in' or\n    // 'given out') which indicates whether or not the amount sent by the pool is known.\n    //\n    // The pool receives `tokenIn` and sends `tokenOut`. `amount` is the number of `tokenIn` tokens the pool will take\n    // in, or the number of `tokenOut` tokens the Pool will send out, depending on the given swap `kind`.\n    //\n    // All other fields are not strictly necessary for most swaps, but are provided to support advanced scenarios in\n    // some Pools.\n    //\n    // `poolId` is the ID of the Pool involved in the swap - this is useful for Pool contracts that implement more than\n    // one Pool.\n    //\n    // The meaning of `lastChangeBlock` depends on the Pool specialization:\n    //  - Two Token or Minimal Swap Info: the last block in which either `tokenIn` or `tokenOut` changed its total\n    //    balance.\n    //  - General: the last block in which *any* of the Pool's registered tokens changed its total balance.\n    //\n    // `from` is the origin address for the funds the Pool receives, and `to` is the destination address\n    // where the Pool sends the outgoing tokens.\n    //\n    // `userData` is extra data provided by the caller - typically a signature from a trusted party.\n    struct SwapRequest {\n        IVault.SwapKind kind;\n        IERC20 tokenIn;\n        IERC20 tokenOut;\n        uint256 amount;\n        // Misc data\n        bytes32 poolId;\n        uint256 lastChangeBlock;\n        address from;\n        address to;\n        bytes userData;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/BaseSplitCodeFactory.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"./BalancerErrors.sol\";\nimport \"./CodeDeployer.sol\";\n\n/**\n * @dev Base factory for contracts whose creation code is so large that the factory cannot hold it. This happens when\n * the contract's creation code grows close to 24kB.\n *\n * Note that this factory cannot help with contracts that have a *runtime* (deployed) bytecode larger than 24kB.\n */\nabstract contract BaseSplitCodeFactory {\n    // The contract's creation code is stored as code in two separate addresses, and retrieved via `extcodecopy`. This\n    // means this factory supports contracts with creation code of up to 48kB.\n    // We rely on inline-assembly to achieve this, both to make the entire operation highly gas efficient, and because\n    // `extcodecopy` is not available in Solidity.\n\n    // solhint-disable no-inline-assembly\n\n    address private immutable _creationCodeContractA;\n    uint256 private immutable _creationCodeSizeA;\n\n    address private immutable _creationCodeContractB;\n    uint256 private immutable _creationCodeSizeB;\n\n    /**\n     * @dev The creation code of a contract Foo can be obtained inside Solidity with `type(Foo).creationCode`.\n     */\n    constructor(bytes memory creationCode) {\n        uint256 creationCodeSize = creationCode.length;\n\n        // We are going to deploy two contracts: one with approximately the first half of `creationCode`'s contents\n        // (A), and another with the remaining half (B).\n        // We store the lengths in both immutable and stack variables, since immutable variables cannot be read during\n        // construction.\n        uint256 creationCodeSizeA = creationCodeSize / 2;\n        _creationCodeSizeA = creationCodeSizeA;\n\n        uint256 creationCodeSizeB = creationCodeSize - creationCodeSizeA;\n        _creationCodeSizeB = creationCodeSizeB;\n\n        // To deploy the contracts, we're going to use `CodeDeployer.deploy()`, which expects a memory array with\n        // the code to deploy. Note that we cannot simply create arrays for A and B's code by copying or moving\n        // `creationCode`'s contents as they are expected to be very large (> 24kB), so we must operate in-place.\n\n        // Memory: [ code length ] [ A.data ] [ B.data ]\n\n        // Creating A's array is simple: we simply replace `creationCode`'s length with A's length. We'll later restore\n        // the original length.\n\n        bytes memory creationCodeA;\n        assembly {\n            creationCodeA := creationCode\n            mstore(creationCodeA, creationCodeSizeA)\n        }\n\n        // Memory: [ A.length ] [ A.data ] [ B.data ]\n        //         ^ creationCodeA\n\n        _creationCodeContractA = CodeDeployer.deploy(creationCodeA);\n\n        // Creating B's array is a bit more involved: since we cannot move B's contents, we are going to create a 'new'\n        // memory array starting at A's last 32 bytes, which will be replaced with B's length. We'll back-up this last\n        // byte to later restore it.\n\n        bytes memory creationCodeB;\n        bytes32 lastByteA;\n\n        assembly {\n            // `creationCode` points to the array's length, not data, so by adding A's length to it we arrive at A's\n            // last 32 bytes.\n            creationCodeB := add(creationCode, creationCodeSizeA)\n            lastByteA := mload(creationCodeB)\n            mstore(creationCodeB, creationCodeSizeB)\n        }\n\n        // Memory: [ A.length ] [ A.data[ : -1] ] [ B.length ][ B.data ]\n        //         ^ creationCodeA                ^ creationCodeB\n\n        _creationCodeContractB = CodeDeployer.deploy(creationCodeB);\n\n        // We now restore the original contents of `creationCode` by writing back the original length and A's last byte.\n        assembly {\n            mstore(creationCodeA, creationCodeSize)\n            mstore(creationCodeB, lastByteA)\n        }\n    }\n\n    /**\n     * @dev Returns the two addresses where the creation code of the contract crated by this factory is stored.\n     */\n    function getCreationCodeContracts() public view returns (address contractA, address contractB) {\n        return (_creationCodeContractA, _creationCodeContractB);\n    }\n\n    /**\n     * @dev Returns the creation code of the contract this factory creates.\n     */\n    function getCreationCode() public view returns (bytes memory) {\n        return _getCreationCodeWithArgs(\"\");\n    }\n\n    /**\n     * @dev Returns the creation code that will result in a contract being deployed with `constructorArgs`.\n     */\n    function _getCreationCodeWithArgs(bytes memory constructorArgs) private view returns (bytes memory code) {\n        // This function exists because `abi.encode()` cannot be instructed to place its result at a specific address.\n        // We need for the ABI-encoded constructor arguments to be located immediately after the creation code, but\n        // cannot rely on `abi.encodePacked()` to perform concatenation as that would involve copying the creation code,\n        // which would be prohibitively expensive.\n        // Instead, we compute the creation code in a pre-allocated array that is large enough to hold *both* the\n        // creation code and the constructor arguments, and then copy the ABI-encoded arguments (which should not be\n        // overly long) right after the end of the creation code.\n\n        // Immutable variables cannot be used in assembly, so we store them in the stack first.\n        address creationCodeContractA = _creationCodeContractA;\n        uint256 creationCodeSizeA = _creationCodeSizeA;\n        address creationCodeContractB = _creationCodeContractB;\n        uint256 creationCodeSizeB = _creationCodeSizeB;\n\n        uint256 creationCodeSize = creationCodeSizeA + creationCodeSizeB;\n        uint256 constructorArgsSize = constructorArgs.length;\n\n        uint256 codeSize = creationCodeSize + constructorArgsSize;\n\n        assembly {\n            // First, we allocate memory for `code` by retrieving the free memory pointer and then moving it ahead of\n            // `code` by the size of the creation code plus constructor arguments, and 32 bytes for the array length.\n            code := mload(0x40)\n            mstore(0x40, add(code, add(codeSize, 32)))\n\n            // We now store the length of the code plus constructor arguments.\n            mstore(code, codeSize)\n\n            // Next, we concatenate the creation code stored in A and B.\n            let dataStart := add(code, 32)\n            extcodecopy(creationCodeContractA, dataStart, 0, creationCodeSizeA)\n            extcodecopy(creationCodeContractB, add(dataStart, creationCodeSizeA), 0, creationCodeSizeB)\n        }\n\n        // Finally, we copy the constructorArgs to the end of the array. Unfortunately there is no way to avoid this\n        // copy, as it is not possible to tell Solidity where to store the result of `abi.encode()`.\n        uint256 constructorArgsDataPtr;\n        uint256 constructorArgsCodeDataPtr;\n        assembly {\n            constructorArgsDataPtr := add(constructorArgs, 32)\n            constructorArgsCodeDataPtr := add(add(code, 32), creationCodeSize)\n        }\n\n        _memcpy(constructorArgsCodeDataPtr, constructorArgsDataPtr, constructorArgsSize);\n    }\n\n    /**\n     * @dev Deploys a contract with constructor arguments. To create `constructorArgs`, call `abi.encode()` with the\n     * contract's constructor arguments, in order.\n     */\n    function _create(bytes memory constructorArgs) internal virtual returns (address) {\n        bytes memory creationCode = _getCreationCodeWithArgs(constructorArgs);\n\n        address destination;\n        assembly {\n            destination := create(0, add(creationCode, 32), mload(creationCode))\n        }\n\n        if (destination == address(0)) {\n            // Bubble up inner revert reason\n            // solhint-disable-next-line no-inline-assembly\n            assembly {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n        }\n\n        return destination;\n    }\n\n    // From\n    // https://github.com/Arachnid/solidity-stringutils/blob/b9a6f6615cf18a87a823cbc461ce9e140a61c305/src/strings.sol\n    function _memcpy(\n        uint256 dest,\n        uint256 src,\n        uint256 len\n    ) private pure {\n        // Copy word-length chunks while possible\n        for (; len >= 32; len -= 32) {\n            assembly {\n                mstore(dest, mload(src))\n            }\n            dest += 32;\n            src += 32;\n        }\n\n        // Copy remaining bytes\n        uint256 mask = 256**(32 - len) - 1;\n        assembly {\n            let srcpart := and(mload(src), not(mask))\n            let destpart := and(mload(dest), mask)\n            mstore(dest, or(destpart, srcpart))\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/CodeDeployer.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"./BalancerErrors.sol\";\n\n/**\n * @dev Library used to deploy contracts with specific code. This can be used for long-term storage of immutable data as\n * contract code, which can be retrieved via the `extcodecopy` opcode.\n */\nlibrary CodeDeployer {\n    // During contract construction, the full code supplied exists as code, and can be accessed via `codesize` and\n    // `codecopy`. This is not the contract's final code however: whatever the constructor returns is what will be\n    // stored as its code.\n    //\n    // We use this mechanism to have a simple constructor that stores whatever is appended to it. The following opcode\n    // sequence corresponds to the creation code of the following equivalent Solidity contract, plus padding to make the\n    // full code 32 bytes long:\n    //\n    // contract CodeDeployer {\n    //     constructor() payable {\n    //         uint256 size;\n    //         assembly {\n    //             size := sub(codesize(), 32) // size of appended data, as constructor is 32 bytes long\n    //             codecopy(0, 32, size) // copy all appended data to memory at position 0\n    //             return(0, size) // return appended data for it to be stored as code\n    //         }\n    //     }\n    // }\n    //\n    // More specifically, it is composed of the following opcodes (plus padding):\n    //\n    // [1] PUSH1 0x20\n    // [2] CODESIZE\n    // [3] SUB\n    // [4] DUP1\n    // [6] PUSH1 0x20\n    // [8] PUSH1 0x00\n    // [9] CODECOPY\n    // [11] PUSH1 0x00\n    // [12] RETURN\n    //\n    // The padding is just the 0xfe sequence (invalid opcode).\n    bytes32\n        private constant _DEPLOYER_CREATION_CODE = 0x602038038060206000396000f3fefefefefefefefefefefefefefefefefefefe;\n\n    /**\n     * @dev Deploys a contract with `code` as its code, returning the destination address.\n     *\n     * Reverts if deployment fails.\n     */\n    function deploy(bytes memory code) internal returns (address destination) {\n        bytes32 deployerCreationCode = _DEPLOYER_CREATION_CODE;\n\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            let codeLength := mload(code)\n\n            // `code` is composed of length and data. We've already stored its length in `codeLength`, so we simply\n            // replace it with the deployer creation code (which is exactly 32 bytes long).\n            mstore(code, deployerCreationCode)\n\n            // At this point, `code` now points to the deployer creation code immediately followed by `code`'s data\n            // contents. This is exactly what the deployer expects to receive when created.\n            destination := create(0, code, add(codeLength, 32))\n\n            // Finally, we restore the original length in order to not mutate `code`.\n            mstore(code, codeLength)\n        }\n\n        // The create opcode returns the zero address when contract creation fails, so we revert if this happens.\n        _require(destination != address(0), Errors.CODE_DEPLOYMENT_FAILED);\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/Fees.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/FixedPoint.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\n\nimport \"./ProtocolFeesCollector.sol\";\nimport \"./VaultAuthorization.sol\";\nimport \"./interfaces/IVault.sol\";\n\n/**\n * @dev To reduce the bytecode size of the Vault, most of the protocol fee logic is not here, but in the\n * ProtocolFeesCollector contract.\n */\nabstract contract Fees is IVault {\n    using SafeERC20 for IERC20;\n\n    ProtocolFeesCollector private immutable _protocolFeesCollector;\n\n    constructor() {\n        _protocolFeesCollector = new ProtocolFeesCollector(IVault(this));\n    }\n\n    function getProtocolFeesCollector() public view override returns (IProtocolFeesCollector) {\n        return _protocolFeesCollector;\n    }\n\n    /**\n     * @dev Returns the protocol swap fee percentage.\n     */\n    function _getProtocolSwapFeePercentage() internal view returns (uint256) {\n        return getProtocolFeesCollector().getSwapFeePercentage();\n    }\n\n    /**\n     * @dev Returns the protocol fee amount to charge for a flash loan of `amount`.\n     */\n    function _calculateFlashLoanFeeAmount(uint256 amount) internal view returns (uint256) {\n        // Fixed point multiplication introduces error: we round up, which means in certain scenarios the charged\n        // percentage can be slightly higher than intended.\n        uint256 percentage = getProtocolFeesCollector().getFlashLoanFeePercentage();\n        return FixedPoint.mulUp(amount, percentage);\n    }\n\n    function _payFeeAmount(IERC20 token, uint256 amount) internal {\n        if (amount > 0) {\n            token.safeTransfer(address(getProtocolFeesCollector()), amount);\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/VaultAuthorization.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/Authentication.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/TemporarilyPausable.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/SignaturesValidator.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\n\nimport \"./interfaces/IVault.sol\";\nimport \"./interfaces/IAuthorizer.sol\";\n\n/**\n * @dev Manages access control of Vault permissioned functions by relying on the Authorizer and signature validation.\n *\n * Additionally handles relayer access and approval.\n */\nabstract contract VaultAuthorization is\n    IVault,\n    ReentrancyGuard,\n    Authentication,\n    SignaturesValidator,\n    TemporarilyPausable\n{\n    // Ideally, we'd store the type hashes as immutable state variables to avoid computing the hash at runtime, but\n    // unfortunately immutable variables cannot be used in assembly, so we just keep the precomputed hashes instead.\n\n    // _JOIN_TYPE_HASH = keccak256(\"JoinPool(bytes calldata,address sender,uint256 nonce,uint256 deadline)\");\n    bytes32 private constant _JOIN_TYPE_HASH = 0x3f7b71252bd19113ff48c19c6e004a9bcfcca320a0d74d58e85877cbd7dcae58;\n\n    // _EXIT_TYPE_HASH = keccak256(\"ExitPool(bytes calldata,address sender,uint256 nonce,uint256 deadline)\");\n    bytes32 private constant _EXIT_TYPE_HASH = 0x8bbc57f66ea936902f50a71ce12b92c43f3c5340bb40c27c4e90ab84eeae3353;\n\n    // _SWAP_TYPE_HASH = keccak256(\"Swap(bytes calldata,address sender,uint256 nonce,uint256 deadline)\");\n    bytes32 private constant _SWAP_TYPE_HASH = 0xe192dcbc143b1e244ad73b813fd3c097b832ad260a157340b4e5e5beda067abe;\n\n    // _BATCH_SWAP_TYPE_HASH = keccak256(\"BatchSwap(bytes calldata,address sender,uint256 nonce,uint256 deadline)\");\n    bytes32 private constant _BATCH_SWAP_TYPE_HASH = 0x9bfc43a4d98313c6766986ffd7c916c7481566d9f224c6819af0a53388aced3a;\n\n    // _SET_RELAYER_TYPE_HASH =\n    //     keccak256(\"SetRelayerApproval(bytes calldata,address sender,uint256 nonce,uint256 deadline)\");\n    bytes32\n        private constant _SET_RELAYER_TYPE_HASH = 0xa3f865aa351e51cfeb40f5178d1564bb629fe9030b83caf6361d1baaf5b90b5a;\n\n    IAuthorizer private _authorizer;\n    mapping(address => mapping(address => bool)) private _approvedRelayers;\n\n    /**\n     * @dev Reverts unless `user` is the caller, or the caller is approved by the Authorizer to call this function (that\n     * is, it is a relayer for that function), and either:\n     *  a) `user` approved the caller as a relayer (via `setRelayerApproval`), or\n     *  b) a valid signature from them was appended to the calldata.\n     *\n     * Should only be applied to external functions.\n     */\n    modifier authenticateFor(address user) {\n        _authenticateFor(user);\n        _;\n    }\n\n    constructor(IAuthorizer authorizer)\n        // The Vault is a singleton, so it simply uses its own address to disambiguate action identifiers.\n        Authentication(bytes32(uint256(address(this))))\n        SignaturesValidator(\"Balancer V2 Vault\")\n    {\n        _setAuthorizer(authorizer);\n    }\n\n    function setAuthorizer(IAuthorizer newAuthorizer) external override nonReentrant authenticate {\n        _setAuthorizer(newAuthorizer);\n    }\n\n    function _setAuthorizer(IAuthorizer newAuthorizer) private {\n        emit AuthorizerChanged(newAuthorizer);\n        _authorizer = newAuthorizer;\n    }\n\n    function getAuthorizer() external view override returns (IAuthorizer) {\n        return _authorizer;\n    }\n\n    function setRelayerApproval(\n        address sender,\n        address relayer,\n        bool approved\n    ) external override nonReentrant whenNotPaused authenticateFor(sender) {\n        _approvedRelayers[sender][relayer] = approved;\n        emit RelayerApprovalChanged(relayer, sender, approved);\n    }\n\n    function hasApprovedRelayer(address user, address relayer) external view override returns (bool) {\n        return _hasApprovedRelayer(user, relayer);\n    }\n\n    /**\n     * @dev Reverts unless `user` is the caller, or the caller is approved by the Authorizer to call the entry point\n     * function (that is, it is a relayer for that function) and either:\n     *  a) `user` approved the caller as a relayer (via `setRelayerApproval`), or\n     *  b) a valid signature from them was appended to the calldata.\n     */\n    function _authenticateFor(address user) internal {\n        if (msg.sender != user) {\n            // In this context, 'permission to call a function' means 'being a relayer for a function'.\n            _authenticateCaller();\n\n            // Being a relayer is not sufficient: `user` must have also approved the caller either via\n            // `setRelayerApproval`, or by providing a signature appended to the calldata.\n            if (!_hasApprovedRelayer(user, msg.sender)) {\n                _validateSignature(user, Errors.USER_DOESNT_ALLOW_RELAYER);\n            }\n        }\n    }\n\n    /**\n     * @dev Returns true if `user` approved `relayer` to act as a relayer for them.\n     */\n    function _hasApprovedRelayer(address user, address relayer) internal view returns (bool) {\n        return _approvedRelayers[user][relayer];\n    }\n\n    function _canPerform(bytes32 actionId, address user) internal view override returns (bool) {\n        // Access control is delegated to the Authorizer.\n        return _authorizer.canPerform(actionId, user, address(this));\n    }\n\n    function _typeHash() internal pure override returns (bytes32 hash) {\n        // This is a simple switch-case statement, trivially written in Solidity by chaining else-if statements, but the\n        // assembly implementation results in much denser bytecode.\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            // The function selector is located at the first 4 bytes of calldata. We copy the first full calldata\n            // 256 word, and then perform a logical shift to the right, moving the selector to the least significant\n            // 4 bytes.\n            let selector := shr(224, calldataload(0))\n\n            // With the selector in the least significant 4 bytes, we can use 4 byte literals with leading zeros,\n            // resulting in dense bytecode (PUSH4 opcodes).\n            switch selector\n                case 0xb95cac28 {\n                    hash := _JOIN_TYPE_HASH\n                }\n                case 0x8bdb3913 {\n                    hash := _EXIT_TYPE_HASH\n                }\n                case 0x52bbbe29 {\n                    hash := _SWAP_TYPE_HASH\n                }\n                case 0x945bcec9 {\n                    hash := _BATCH_SWAP_TYPE_HASH\n                }\n                case 0xfa6e671d {\n                    hash := _SET_RELAYER_TYPE_HASH\n                }\n                default {\n                    hash := 0x0000000000000000000000000000000000000000000000000000000000000000\n                }\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/ProtocolFeesCollector.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/Authentication.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\n\nimport \"./interfaces/IProtocolFeesCollector.sol\";\n\n/**\n * @dev This an auxiliary contract to the Vault, deployed by it during construction. It offloads some of the tasks the\n * Vault performs to reduce its overall bytecode size.\n *\n * The current values for all protocol fee percentages are stored here, and any tokens charged as protocol fees are\n * sent to this contract, where they may be withdrawn by authorized entities. All authorization tasks are delegated\n * to the Vault's own authorizer.\n */\ncontract ProtocolFeesCollector is IProtocolFeesCollector, Authentication, ReentrancyGuard {\n    using SafeERC20 for IERC20;\n\n    // Absolute maximum fee percentages (1e18 = 100%, 1e16 = 1%).\n    uint256 private constant _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE = 50e16; // 50%\n    uint256 private constant _MAX_PROTOCOL_FLASH_LOAN_FEE_PERCENTAGE = 1e16; // 1%\n\n    IVault public immutable override vault;\n\n    // All fee percentages are 18-decimal fixed point numbers.\n\n    // The swap fee is charged whenever a swap occurs, as a percentage of the fee charged by the Pool. These are not\n    // actually charged on each individual swap: the `Vault` relies on the Pools being honest and reporting fees due\n    // when users join and exit them.\n    uint256 private _swapFeePercentage;\n\n    // The flash loan fee is charged whenever a flash loan occurs, as a percentage of the tokens lent.\n    uint256 private _flashLoanFeePercentage;\n\n    constructor(IVault _vault)\n        // The ProtocolFeesCollector is a singleton, so it simply uses its own address to disambiguate action\n        // identifiers.\n        Authentication(bytes32(uint256(address(this))))\n    {\n        vault = _vault;\n    }\n\n    function withdrawCollectedFees(\n        IERC20[] calldata tokens,\n        uint256[] calldata amounts,\n        address recipient\n    ) external override nonReentrant authenticate {\n        InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length);\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            IERC20 token = tokens[i];\n            uint256 amount = amounts[i];\n            token.safeTransfer(recipient, amount);\n        }\n    }\n\n    function setSwapFeePercentage(uint256 newSwapFeePercentage) external override authenticate {\n        _require(newSwapFeePercentage <= _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE, Errors.SWAP_FEE_PERCENTAGE_TOO_HIGH);\n        _swapFeePercentage = newSwapFeePercentage;\n        emit SwapFeePercentageChanged(newSwapFeePercentage);\n    }\n\n    function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external override authenticate {\n        _require(\n            newFlashLoanFeePercentage <= _MAX_PROTOCOL_FLASH_LOAN_FEE_PERCENTAGE,\n            Errors.FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH\n        );\n        _flashLoanFeePercentage = newFlashLoanFeePercentage;\n        emit FlashLoanFeePercentageChanged(newFlashLoanFeePercentage);\n    }\n\n    function getSwapFeePercentage() external view override returns (uint256) {\n        return _swapFeePercentage;\n    }\n\n    function getFlashLoanFeePercentage() external view override returns (uint256) {\n        return _flashLoanFeePercentage;\n    }\n\n    function getCollectedFeeAmounts(IERC20[] memory tokens)\n        external\n        view\n        override\n        returns (uint256[] memory feeAmounts)\n    {\n        feeAmounts = new uint256[](tokens.length);\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            feeAmounts[i] = tokens[i].balanceOf(address(this));\n        }\n    }\n\n    function getAuthorizer() external view override returns (IAuthorizer) {\n        return _getAuthorizer();\n    }\n\n    function _canPerform(bytes32 actionId, address account) internal view override returns (bool) {\n        return _getAuthorizer().canPerform(actionId, account, address(this));\n    }\n\n    function _getAuthorizer() internal view returns (IAuthorizer) {\n        return vault.getAuthorizer();\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\n// Based on the ReentrancyGuard library from OpenZeppelin Contracts, altered to reduce bytecode size.\n// Modifier code is inlined by the compiler, which causes its code to appear multiple times in the codebase. By using\n// private functions, we achieve the same end result with slightly higher runtime gas costs, but reduced bytecode size.\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant _NOT_ENTERED = 1;\n    uint256 private constant _ENTERED = 2;\n\n    uint256 private _status;\n\n    constructor() {\n        _status = _NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and make it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _enterNonReentrant();\n        _;\n        _exitNonReentrant();\n    }\n\n    function _enterNonReentrant() private {\n        // On the first call to nonReentrant, _status will be _NOT_ENTERED\n        _require(_status != _ENTERED, Errors.REENTRANCY);\n\n        // Any calls to nonReentrant after this point will fail\n        _status = _ENTERED;\n    }\n\n    function _exitNonReentrant() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = _NOT_ENTERED;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\n// Based on the ReentrancyGuard library from OpenZeppelin Contracts, altered to reduce gas costs.\n// The `safeTransfer` and `safeTransferFrom` functions assume that `token` is a contract (an account with code), and\n// work differently from the OpenZeppelin version if it is not.\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\nimport \"./IERC20.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    function safeTransfer(\n        IERC20 token,\n        address to,\n        uint256 value\n    ) internal {\n        _callOptionalReturn(address(token), abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value\n    ) internal {\n        _callOptionalReturn(address(token), abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * WARNING: `token` is assumed to be a contract: calls to EOAs will *not* revert.\n     */\n    function _callOptionalReturn(address token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves.\n        (bool success, bytes memory returndata) = token.call(data);\n\n        // If the low-level call didn't succeed we return whatever was returned from it.\n        assembly {\n            if eq(success, 0) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n        }\n\n        // Finally we check the returndata size is either zero or true - note that this check will always pass for EOAs\n        _require(returndata.length == 0 || abi.decode(returndata, (bool)), Errors.SAFE_ERC20_CALL_FAILED);\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/Authentication.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"./BalancerErrors.sol\";\nimport \"./IAuthentication.sol\";\n\n/**\n * @dev Building block for performing access control on external functions.\n *\n * This contract is used via the `authenticate` modifier (or the `_authenticateCaller` function), which can be applied\n * to external functions to only make them callable by authorized accounts.\n *\n * Derived contracts must implement the `_canPerform` function, which holds the actual access control logic.\n */\nabstract contract Authentication is IAuthentication {\n    bytes32 private immutable _actionIdDisambiguator;\n\n    /**\n     * @dev The main purpose of the `actionIdDisambiguator` is to prevent accidental function selector collisions in\n     * multi contract systems.\n     *\n     * There are two main uses for it:\n     *  - if the contract is a singleton, any unique identifier can be used to make the associated action identifiers\n     *    unique. The contract's own address is a good option.\n     *  - if the contract belongs to a family that shares action identifiers for the same functions, an identifier\n     *    shared by the entire family (and no other contract) should be used instead.\n     */\n    constructor(bytes32 actionIdDisambiguator) {\n        _actionIdDisambiguator = actionIdDisambiguator;\n    }\n\n    /**\n     * @dev Reverts unless the caller is allowed to call this function. Should only be applied to external functions.\n     */\n    modifier authenticate() {\n        _authenticateCaller();\n        _;\n    }\n\n    /**\n     * @dev Reverts unless the caller is allowed to call the entry point function.\n     */\n    function _authenticateCaller() internal view {\n        bytes32 actionId = getActionId(msg.sig);\n        _require(_canPerform(actionId, msg.sender), Errors.SENDER_NOT_ALLOWED);\n    }\n\n    function getActionId(bytes4 selector) public view override returns (bytes32) {\n        // Each external function is dynamically assigned an action identifier as the hash of the disambiguator and the\n        // function selector. Disambiguation is necessary to avoid potential collisions in the function selectors of\n        // multiple contracts.\n        return keccak256(abi.encodePacked(_actionIdDisambiguator, selector));\n    }\n\n    function _canPerform(bytes32 actionId, address user) internal view virtual returns (bool);\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/TemporarilyPausable.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"./BalancerErrors.sol\";\nimport \"./ITemporarilyPausable.sol\";\n\n/**\n * @dev Allows for a contract to be paused during an initial period after deployment, disabling functionality. Can be\n * used as an emergency switch in case a security vulnerability or threat is identified.\n *\n * The contract can only be paused during the Pause Window, a period that starts at deployment. It can also be\n * unpaused and repaused any number of times during this period. This is intended to serve as a safety measure: it lets\n * system managers react quickly to potentially dangerous situations, knowing that this action is reversible if careful\n * analysis later determines there was a false alarm.\n *\n * If the contract is paused when the Pause Window finishes, it will remain in the paused state through an additional\n * Buffer Period, after which it will be automatically unpaused forever. This is to ensure there is always enough time\n * to react to an emergency, even if the threat is discovered shortly before the Pause Window expires.\n *\n * Note that since the contract can only be paused within the Pause Window, unpausing during the Buffer Period is\n * irreversible.\n */\nabstract contract TemporarilyPausable is ITemporarilyPausable {\n    // The Pause Window and Buffer Period are timestamp-based: they should not be relied upon for sub-minute accuracy.\n    // solhint-disable not-rely-on-time\n\n    uint256 private constant _MAX_PAUSE_WINDOW_DURATION = 90 days;\n    uint256 private constant _MAX_BUFFER_PERIOD_DURATION = 30 days;\n\n    uint256 private immutable _pauseWindowEndTime;\n    uint256 private immutable _bufferPeriodEndTime;\n\n    bool private _paused;\n\n    constructor(uint256 pauseWindowDuration, uint256 bufferPeriodDuration) {\n        _require(pauseWindowDuration <= _MAX_PAUSE_WINDOW_DURATION, Errors.MAX_PAUSE_WINDOW_DURATION);\n        _require(bufferPeriodDuration <= _MAX_BUFFER_PERIOD_DURATION, Errors.MAX_BUFFER_PERIOD_DURATION);\n\n        uint256 pauseWindowEndTime = block.timestamp + pauseWindowDuration;\n\n        _pauseWindowEndTime = pauseWindowEndTime;\n        _bufferPeriodEndTime = pauseWindowEndTime + bufferPeriodDuration;\n    }\n\n    /**\n     * @dev Reverts if the contract is paused.\n     */\n    modifier whenNotPaused() {\n        _ensureNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Returns the current contract pause status, as well as the end times of the Pause Window and Buffer\n     * Period.\n     */\n    function getPausedState()\n        external\n        view\n        override\n        returns (\n            bool paused,\n            uint256 pauseWindowEndTime,\n            uint256 bufferPeriodEndTime\n        )\n    {\n        paused = !_isNotPaused();\n        pauseWindowEndTime = _getPauseWindowEndTime();\n        bufferPeriodEndTime = _getBufferPeriodEndTime();\n    }\n\n    /**\n     * @dev Sets the pause state to `paused`. The contract can only be paused until the end of the Pause Window, and\n     * unpaused until the end of the Buffer Period.\n     *\n     * Once the Buffer Period expires, this function reverts unconditionally.\n     */\n    function _setPaused(bool paused) internal {\n        if (paused) {\n            _require(block.timestamp < _getPauseWindowEndTime(), Errors.PAUSE_WINDOW_EXPIRED);\n        } else {\n            _require(block.timestamp < _getBufferPeriodEndTime(), Errors.BUFFER_PERIOD_EXPIRED);\n        }\n\n        _paused = paused;\n        emit PausedStateChanged(paused);\n    }\n\n    /**\n     * @dev Reverts if the contract is paused.\n     */\n    function _ensureNotPaused() internal view {\n        _require(_isNotPaused(), Errors.PAUSED);\n    }\n\n    /**\n     * @dev Returns true if the contract is unpaused.\n     *\n     * Once the Buffer Period expires, the gas cost of calling this function is reduced dramatically, as storage is no\n     * longer accessed.\n     */\n    function _isNotPaused() internal view returns (bool) {\n        // After the Buffer Period, the (inexpensive) timestamp check short-circuits the storage access.\n        return block.timestamp > _getBufferPeriodEndTime() || !_paused;\n    }\n\n    // These getters lead to reduced bytecode size by inlining the immutable variables in a single place.\n\n    function _getPauseWindowEndTime() private view returns (uint256) {\n        return _pauseWindowEndTime;\n    }\n\n    function _getBufferPeriodEndTime() private view returns (uint256) {\n        return _bufferPeriodEndTime;\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/SignaturesValidator.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"./BalancerErrors.sol\";\nimport \"./ISignaturesValidator.sol\";\nimport \"../openzeppelin/EIP712.sol\";\n\n/**\n * @dev Utility for signing Solidity function calls.\n *\n * This contract relies on the fact that Solidity contracts can be called with extra calldata, and enables\n * meta-transaction schemes by appending an EIP712 signature of the original calldata at the end.\n *\n * Derived contracts must implement the `_typeHash` function to map function selectors to EIP712 structs.\n */\nabstract contract SignaturesValidator is ISignaturesValidator, EIP712 {\n    // The appended data consists of a deadline, plus the [v,r,s] signature. For simplicity, we use a full 256 bit slot\n    // for each of these values, even if 'v' is typically an 8 bit value.\n    uint256 internal constant _EXTRA_CALLDATA_LENGTH = 4 * 32;\n\n    // Replay attack prevention for each user.\n    mapping(address => uint256) internal _nextNonce;\n\n    constructor(string memory name) EIP712(name, \"1\") {\n        // solhint-disable-previous-line no-empty-blocks\n    }\n\n    function getDomainSeparator() external view override returns (bytes32) {\n        return _domainSeparatorV4();\n    }\n\n    function getNextNonce(address user) external view override returns (uint256) {\n        return _nextNonce[user];\n    }\n\n    /**\n     * @dev Reverts with `errorCode` unless a valid signature for `user` was appended to the calldata.\n     */\n    function _validateSignature(address user, uint256 errorCode) internal {\n        uint256 nextNonce = _nextNonce[user]++;\n        _require(_isSignatureValid(user, nextNonce), errorCode);\n    }\n\n    function _isSignatureValid(address user, uint256 nonce) private view returns (bool) {\n        uint256 deadline = _deadline();\n\n        // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy.\n        // solhint-disable-next-line not-rely-on-time\n        if (deadline < block.timestamp) {\n            return false;\n        }\n\n        bytes32 typeHash = _typeHash();\n        if (typeHash == bytes32(0)) {\n            // Prevent accidental signature validation for functions that don't have an associated type hash.\n            return false;\n        }\n\n        // All type hashes have this format: (bytes calldata, address sender, uint256 nonce, uint256 deadline).\n        bytes32 structHash = keccak256(abi.encode(typeHash, keccak256(_calldata()), msg.sender, nonce, deadline));\n        bytes32 digest = _hashTypedDataV4(structHash);\n        (uint8 v, bytes32 r, bytes32 s) = _signature();\n\n        address recoveredAddress = ecrecover(digest, v, r, s);\n\n        // ecrecover returns the zero address on recover failure, so we need to handle that explicitly.\n        return recoveredAddress != address(0) && recoveredAddress == user;\n    }\n\n    /**\n     * @dev Returns the EIP712 type hash for the current entry point function, which can be identified by its function\n     * selector (available as `msg.sig`).\n     *\n     * The type hash must conform to the following format:\n     *  <name>(bytes calldata, address sender, uint256 nonce, uint256 deadline)\n     *\n     * If 0x00, all signatures will be considered invalid.\n     */\n    function _typeHash() internal view virtual returns (bytes32);\n\n    /**\n     * @dev Extracts the signature deadline from extra calldata.\n     *\n     * This function returns bogus data if no signature is included.\n     */\n    function _deadline() internal pure returns (uint256) {\n        // The deadline is the first extra argument at the end of the original calldata.\n        return uint256(_decodeExtraCalldataWord(0));\n    }\n\n    /**\n     * @dev Extracts the signature parameters from extra calldata.\n     *\n     * This function returns bogus data if no signature is included. This is not a security risk, as that data would not\n     * be considered a valid signature in the first place.\n     */\n    function _signature()\n        internal\n        pure\n        returns (\n            uint8 v,\n            bytes32 r,\n            bytes32 s\n        )\n    {\n        // v, r and s are appended after the signature deadline, in that order.\n        v = uint8(uint256(_decodeExtraCalldataWord(0x20)));\n        r = _decodeExtraCalldataWord(0x40);\n        s = _decodeExtraCalldataWord(0x60);\n    }\n\n    /**\n     * @dev Returns the original calldata, without the extra bytes containing the signature.\n     *\n     * This function returns bogus data if no signature is included.\n     */\n    function _calldata() internal pure returns (bytes memory result) {\n        result = msg.data; // A calldata to memory assignment results in memory allocation and copy of contents.\n        if (result.length > _EXTRA_CALLDATA_LENGTH) {\n            // solhint-disable-next-line no-inline-assembly\n            assembly {\n                // We simply overwrite the array length with the reduced one.\n                mstore(result, sub(calldatasize(), _EXTRA_CALLDATA_LENGTH))\n            }\n        }\n    }\n\n    /**\n     * @dev Returns a 256 bit word from 'extra' calldata, at some offset from the expected end of the original calldata.\n     *\n     * This function returns bogus data if no signature is included.\n     */\n    function _decodeExtraCalldataWord(uint256 offset) private pure returns (bytes32 result) {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            result := calldataload(add(sub(calldatasize(), _EXTRA_CALLDATA_LENGTH), offset))\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/IAuthentication.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\ninterface IAuthentication {\n    /**\n     * @dev Returns the action identifier associated with the external function described by `selector`.\n     */\n    function getActionId(bytes4 selector) external view returns (bytes32);\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"../openzeppelin/IERC20.sol\";\n\nimport \"./BalancerErrors.sol\";\n\nlibrary InputHelpers {\n    function ensureInputLengthMatch(uint256 a, uint256 b) internal pure {\n        _require(a == b, Errors.INPUT_LENGTH_MISMATCH);\n    }\n\n    function ensureInputLengthMatch(\n        uint256 a,\n        uint256 b,\n        uint256 c\n    ) internal pure {\n        _require(a == b && b == c, Errors.INPUT_LENGTH_MISMATCH);\n    }\n\n    function ensureArrayIsSorted(IERC20[] memory array) internal pure {\n        address[] memory addressArray;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            addressArray := array\n        }\n        ensureArrayIsSorted(addressArray);\n    }\n\n    function ensureArrayIsSorted(address[] memory array) internal pure {\n        if (array.length < 2) {\n            return;\n        }\n\n        address previous = array[0];\n        for (uint256 i = 1; i < array.length; ++i) {\n            address current = array[i];\n            _require(previous < current, Errors.UNSORTED_ARRAY);\n            previous = current;\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/PoolBalances.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\n\nimport \"./Fees.sol\";\nimport \"./PoolTokens.sol\";\nimport \"./UserBalance.sol\";\nimport \"./interfaces/IBasePool.sol\";\n\n/**\n * @dev Stores the Asset Managers (by Pool and token), and implements the top level Asset Manager and Pool interfaces,\n * such as registering and deregistering tokens, joining and exiting Pools, and informational functions like `getPool`\n * and `getPoolTokens`, delegating to specialization-specific functions as needed.\n *\n * `managePoolBalance` handles all Asset Manager interactions.\n */\nabstract contract PoolBalances is Fees, ReentrancyGuard, PoolTokens, UserBalance {\n    using Math for uint256;\n    using SafeERC20 for IERC20;\n    using BalanceAllocation for bytes32;\n    using BalanceAllocation for bytes32[];\n\n    function joinPool(\n        bytes32 poolId,\n        address sender,\n        address recipient,\n        JoinPoolRequest memory request\n    ) external payable override whenNotPaused {\n        // This function doesn't have the nonReentrant modifier: it is applied to `_joinOrExit` instead.\n\n        // Note that `recipient` is not actually payable in the context of a join - we cast it because we handle both\n        // joins and exits at once.\n        _joinOrExit(PoolBalanceChangeKind.JOIN, poolId, sender, payable(recipient), _toPoolBalanceChange(request));\n    }\n\n    function exitPool(\n        bytes32 poolId,\n        address sender,\n        address payable recipient,\n        ExitPoolRequest memory request\n    ) external override {\n        // This function doesn't have the nonReentrant modifier: it is applied to `_joinOrExit` instead.\n        _joinOrExit(PoolBalanceChangeKind.EXIT, poolId, sender, recipient, _toPoolBalanceChange(request));\n    }\n\n    // This has the exact same layout as JoinPoolRequest and ExitPoolRequest, except the `maxAmountsIn` and\n    // `minAmountsOut` are called `limits`. Internally we use this struct for both since these two functions are quite\n    // similar, but expose the others to callers for clarity.\n    struct PoolBalanceChange {\n        IAsset[] assets;\n        uint256[] limits;\n        bytes userData;\n        bool useInternalBalance;\n    }\n\n    /**\n     * @dev Converts a JoinPoolRequest into a PoolBalanceChange, with no runtime cost.\n     */\n    function _toPoolBalanceChange(JoinPoolRequest memory request)\n        private\n        pure\n        returns (PoolBalanceChange memory change)\n    {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            change := request\n        }\n    }\n\n    /**\n     * @dev Converts an ExitPoolRequest into a PoolBalanceChange, with no runtime cost.\n     */\n    function _toPoolBalanceChange(ExitPoolRequest memory request)\n        private\n        pure\n        returns (PoolBalanceChange memory change)\n    {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            change := request\n        }\n    }\n\n    /**\n     * @dev Implements both `joinPool` and `exitPool`, based on `kind`.\n     */\n    function _joinOrExit(\n        PoolBalanceChangeKind kind,\n        bytes32 poolId,\n        address sender,\n        address payable recipient,\n        PoolBalanceChange memory change\n    ) private nonReentrant withRegisteredPool(poolId) authenticateFor(sender) {\n        // This function uses a large number of stack variables (poolId, sender and recipient, balances, amounts, fees,\n        // etc.), which leads to 'stack too deep' issues. It relies on private functions with seemingly arbitrary\n        // interfaces to work around this limitation.\n\n        InputHelpers.ensureInputLengthMatch(change.assets.length, change.limits.length);\n\n        // We first check that the caller passed the Pool's registered tokens in the correct order, and retrieve the\n        // current balance for each.\n        IERC20[] memory tokens = _translateToIERC20(change.assets);\n        bytes32[] memory balances = _validateTokensAndGetBalances(poolId, tokens);\n\n        // The bulk of the work is done here: the corresponding Pool hook is called, its final balances are computed,\n        // assets are transferred, and fees are paid.\n        (\n            bytes32[] memory finalBalances,\n            uint256[] memory amountsInOrOut,\n            uint256[] memory paidProtocolSwapFeeAmounts\n        ) = _callPoolBalanceChange(kind, poolId, sender, recipient, change, balances);\n\n        // All that remains is storing the new Pool balances.\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            _setTwoTokenPoolCashBalances(poolId, tokens[0], finalBalances[0], tokens[1], finalBalances[1]);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            _setMinimalSwapInfoPoolBalances(poolId, tokens, finalBalances);\n        } else {\n            // PoolSpecialization.GENERAL\n            _setGeneralPoolBalances(poolId, finalBalances);\n        }\n\n        bool positive = kind == PoolBalanceChangeKind.JOIN; // Amounts in are positive, out are negative\n        emit PoolBalanceChanged(\n            poolId,\n            sender,\n            tokens,\n            // We can unsafely cast to int256 because balances are actually stored as uint112\n            _unsafeCastToInt256(amountsInOrOut, positive),\n            paidProtocolSwapFeeAmounts\n        );\n    }\n\n    /**\n     * @dev Calls the corresponding Pool hook to get the amounts in/out plus protocol fee amounts, and performs the\n     * associated token transfers and fee payments, returning the Pool's final balances.\n     */\n    function _callPoolBalanceChange(\n        PoolBalanceChangeKind kind,\n        bytes32 poolId,\n        address sender,\n        address payable recipient,\n        PoolBalanceChange memory change,\n        bytes32[] memory balances\n    )\n        private\n        returns (\n            bytes32[] memory finalBalances,\n            uint256[] memory amountsInOrOut,\n            uint256[] memory dueProtocolFeeAmounts\n        )\n    {\n        (uint256[] memory totalBalances, uint256 lastChangeBlock) = balances.totalsAndLastChangeBlock();\n\n        IBasePool pool = IBasePool(_getPoolAddress(poolId));\n        (amountsInOrOut, dueProtocolFeeAmounts) = kind == PoolBalanceChangeKind.JOIN\n            ? pool.onJoinPool(\n                poolId,\n                sender,\n                recipient,\n                totalBalances,\n                lastChangeBlock,\n                _getProtocolSwapFeePercentage(),\n                change.userData\n            )\n            : pool.onExitPool(\n                poolId,\n                sender,\n                recipient,\n                totalBalances,\n                lastChangeBlock,\n                _getProtocolSwapFeePercentage(),\n                change.userData\n            );\n\n        InputHelpers.ensureInputLengthMatch(balances.length, amountsInOrOut.length, dueProtocolFeeAmounts.length);\n\n        // The Vault ignores the `recipient` in joins and the `sender` in exits: it is up to the Pool to keep track of\n        // their participation.\n        finalBalances = kind == PoolBalanceChangeKind.JOIN\n            ? _processJoinPoolTransfers(sender, change, balances, amountsInOrOut, dueProtocolFeeAmounts)\n            : _processExitPoolTransfers(recipient, change, balances, amountsInOrOut, dueProtocolFeeAmounts);\n    }\n\n    /**\n     * @dev Transfers `amountsIn` from `sender`, checking that they are within their accepted limits, and pays\n     * accumulated protocol swap fees.\n     *\n     * Returns the Pool's final balances, which are the current balances plus `amountsIn` minus accumulated protocol\n     * swap fees.\n     */\n    function _processJoinPoolTransfers(\n        address sender,\n        PoolBalanceChange memory change,\n        bytes32[] memory balances,\n        uint256[] memory amountsIn,\n        uint256[] memory dueProtocolFeeAmounts\n    ) private returns (bytes32[] memory finalBalances) {\n        // We need to track how much of the received ETH was used and wrapped into WETH to return any excess.\n        uint256 wrappedEth = 0;\n\n        finalBalances = new bytes32[](balances.length);\n        for (uint256 i = 0; i < change.assets.length; ++i) {\n            uint256 amountIn = amountsIn[i];\n            _require(amountIn <= change.limits[i], Errors.JOIN_ABOVE_MAX);\n\n            // Receive assets from the sender - possibly from Internal Balance.\n            IAsset asset = change.assets[i];\n            _receiveAsset(asset, amountIn, sender, change.useInternalBalance);\n\n            if (_isETH(asset)) {\n                wrappedEth = wrappedEth.add(amountIn);\n            }\n\n            uint256 feeAmount = dueProtocolFeeAmounts[i];\n            _payFeeAmount(_translateToIERC20(asset), feeAmount);\n\n            // Compute the new Pool balances. Note that the fee amount might be larger than `amountIn`,\n            // resulting in an overall decrease of the Pool's balance for a token.\n            finalBalances[i] = (amountIn >= feeAmount) // This lets us skip checked arithmetic\n                ? balances[i].increaseCash(amountIn - feeAmount)\n                : balances[i].decreaseCash(feeAmount - amountIn);\n        }\n\n        // Handle any used and remaining ETH.\n        _handleRemainingEth(wrappedEth);\n    }\n\n    /**\n     * @dev Transfers `amountsOut` to `recipient`, checking that they are within their accepted limits, and pays\n     * accumulated protocol swap fees from the Pool.\n     *\n     * Returns the Pool's final balances, which are the current `balances` minus `amountsOut` and fees paid\n     * (`dueProtocolFeeAmounts`).\n     */\n    function _processExitPoolTransfers(\n        address payable recipient,\n        PoolBalanceChange memory change,\n        bytes32[] memory balances,\n        uint256[] memory amountsOut,\n        uint256[] memory dueProtocolFeeAmounts\n    ) private returns (bytes32[] memory finalBalances) {\n        finalBalances = new bytes32[](balances.length);\n        for (uint256 i = 0; i < change.assets.length; ++i) {\n            uint256 amountOut = amountsOut[i];\n            _require(amountOut >= change.limits[i], Errors.EXIT_BELOW_MIN);\n\n            // Send tokens to the recipient - possibly to Internal Balance\n            IAsset asset = change.assets[i];\n            _sendAsset(asset, amountOut, recipient, change.useInternalBalance);\n\n            uint256 feeAmount = dueProtocolFeeAmounts[i];\n            _payFeeAmount(_translateToIERC20(asset), feeAmount);\n\n            // Compute the new Pool balances. A Pool's token balance always decreases after an exit (potentially by 0).\n            finalBalances[i] = balances[i].decreaseCash(amountOut.add(feeAmount));\n        }\n    }\n\n    /**\n     * @dev Returns the total balance for `poolId`'s `expectedTokens`.\n     *\n     * `expectedTokens` must exactly equal the token array returned by `getPoolTokens`: both arrays must have the same\n     * length, elements and order. Additionally, the Pool must have at least one registered token.\n     */\n    function _validateTokensAndGetBalances(bytes32 poolId, IERC20[] memory expectedTokens)\n        private\n        view\n        returns (bytes32[] memory)\n    {\n        (IERC20[] memory actualTokens, bytes32[] memory balances) = _getPoolTokens(poolId);\n        InputHelpers.ensureInputLengthMatch(actualTokens.length, expectedTokens.length);\n        _require(actualTokens.length > 0, Errors.POOL_NO_TOKENS);\n\n        for (uint256 i = 0; i < actualTokens.length; ++i) {\n            _require(actualTokens[i] == expectedTokens[i], Errors.TOKENS_MISMATCH);\n        }\n\n        return balances;\n    }\n\n    /**\n     * @dev Casts an array of uint256 to int256, setting the sign of the result according to the `positive` flag,\n     * without checking whether the values fit in the signed 256 bit range.\n     */\n    function _unsafeCastToInt256(uint256[] memory values, bool positive)\n        private\n        pure\n        returns (int256[] memory signedValues)\n    {\n        signedValues = new int256[](values.length);\n        for (uint256 i = 0; i < values.length; i++) {\n            signedValues[i] = positive ? int256(values[i]) : -int256(values[i]);\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/UserBalance.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeCast.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\n\nimport \"./AssetTransfersHandler.sol\";\nimport \"./VaultAuthorization.sol\";\n\n/**\n * Implement User Balance interactions, which combine Internal Balance and using the Vault's ERC20 allowance.\n *\n * Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later\n * transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination\n * when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced\n * gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users.\n *\n * Internal Balance management features batching, which means a single contract call can be used to perform multiple\n * operations of different kinds, with different senders and recipients, at once.\n */\nabstract contract UserBalance is ReentrancyGuard, AssetTransfersHandler, VaultAuthorization {\n    using Math for uint256;\n    using SafeCast for uint256;\n    using SafeERC20 for IERC20;\n\n    // Internal Balance for each token, for each account.\n    mapping(address => mapping(IERC20 => uint256)) private _internalTokenBalance;\n\n    function getInternalBalance(address user, IERC20[] memory tokens)\n        external\n        view\n        override\n        returns (uint256[] memory balances)\n    {\n        balances = new uint256[](tokens.length);\n        for (uint256 i = 0; i < tokens.length; i++) {\n            balances[i] = _getInternalBalance(user, tokens[i]);\n        }\n    }\n\n    function manageUserBalance(UserBalanceOp[] memory ops) external payable override nonReentrant {\n        // We need to track how much of the received ETH was used and wrapped into WETH to return any excess.\n        uint256 ethWrapped = 0;\n\n        // Cache for these checks so we only perform them once (if at all).\n        bool checkedCallerIsRelayer = false;\n        bool checkedNotPaused = false;\n\n        for (uint256 i = 0; i < ops.length; i++) {\n            UserBalanceOpKind kind;\n            IAsset asset;\n            uint256 amount;\n            address sender;\n            address payable recipient;\n\n            // This destructuring by calling `_validateUserBalanceOp` seems odd, but results in reduced bytecode size.\n            (kind, asset, amount, sender, recipient, checkedCallerIsRelayer) = _validateUserBalanceOp(\n                ops[i],\n                checkedCallerIsRelayer\n            );\n\n            if (kind == UserBalanceOpKind.WITHDRAW_INTERNAL) {\n                // Internal Balance withdrawals can always be performed by an authorized account.\n                _withdrawFromInternalBalance(asset, sender, recipient, amount);\n            } else {\n                // All other operations are blocked if the contract is paused.\n\n                // We cache the result of the pause check and skip it for other operations in this same transaction\n                // (if any).\n                if (!checkedNotPaused) {\n                    _ensureNotPaused();\n                    checkedNotPaused = true;\n                }\n\n                if (kind == UserBalanceOpKind.DEPOSIT_INTERNAL) {\n                    _depositToInternalBalance(asset, sender, recipient, amount);\n\n                    // Keep track of all ETH wrapped into WETH as part of a deposit.\n                    if (_isETH(asset)) {\n                        ethWrapped = ethWrapped.add(amount);\n                    }\n                } else {\n                    // Transfers don't support ETH.\n                    _require(!_isETH(asset), Errors.CANNOT_USE_ETH_SENTINEL);\n                    IERC20 token = _asIERC20(asset);\n\n                    if (kind == UserBalanceOpKind.TRANSFER_INTERNAL) {\n                        _transferInternalBalance(token, sender, recipient, amount);\n                    } else {\n                        // TRANSFER_EXTERNAL\n                        _transferToExternalBalance(token, sender, recipient, amount);\n                    }\n                }\n            }\n        }\n\n        // Handle any remaining ETH.\n        _handleRemainingEth(ethWrapped);\n    }\n\n    function _depositToInternalBalance(\n        IAsset asset,\n        address sender,\n        address recipient,\n        uint256 amount\n    ) private {\n        _increaseInternalBalance(recipient, _translateToIERC20(asset), amount);\n        _receiveAsset(asset, amount, sender, false);\n    }\n\n    function _withdrawFromInternalBalance(\n        IAsset asset,\n        address sender,\n        address payable recipient,\n        uint256 amount\n    ) private {\n        // A partial decrease of Internal Balance is disallowed: `sender` must have the full `amount`.\n        _decreaseInternalBalance(sender, _translateToIERC20(asset), amount, false);\n        _sendAsset(asset, amount, recipient, false);\n    }\n\n    function _transferInternalBalance(\n        IERC20 token,\n        address sender,\n        address recipient,\n        uint256 amount\n    ) private {\n        // A partial decrease of Internal Balance is disallowed: `sender` must have the full `amount`.\n        _decreaseInternalBalance(sender, token, amount, false);\n        _increaseInternalBalance(recipient, token, amount);\n    }\n\n    function _transferToExternalBalance(\n        IERC20 token,\n        address sender,\n        address recipient,\n        uint256 amount\n    ) private {\n        if (amount > 0) {\n            token.safeTransferFrom(sender, recipient, amount);\n            emit ExternalBalanceTransfer(token, sender, recipient, amount);\n        }\n    }\n\n    /**\n     * @dev Increases `account`'s Internal Balance for `token` by `amount`.\n     */\n    function _increaseInternalBalance(\n        address account,\n        IERC20 token,\n        uint256 amount\n    ) internal override {\n        uint256 currentBalance = _getInternalBalance(account, token);\n        uint256 newBalance = currentBalance.add(amount);\n        _setInternalBalance(account, token, newBalance, amount.toInt256());\n    }\n\n    /**\n     * @dev Decreases `account`'s Internal Balance for `token` by `amount`. If `allowPartial` is true, this function\n     * doesn't revert if `account` doesn't have enough balance, and sets it to zero and returns the deducted amount\n     * instead.\n     */\n    function _decreaseInternalBalance(\n        address account,\n        IERC20 token,\n        uint256 amount,\n        bool allowPartial\n    ) internal override returns (uint256 deducted) {\n        uint256 currentBalance = _getInternalBalance(account, token);\n        _require(allowPartial || (currentBalance >= amount), Errors.INSUFFICIENT_INTERNAL_BALANCE);\n\n        deducted = Math.min(currentBalance, amount);\n        // By construction, `deducted` is lower or equal to `currentBalance`, so we don't need to use checked\n        // arithmetic.\n        uint256 newBalance = currentBalance - deducted;\n        _setInternalBalance(account, token, newBalance, -(deducted.toInt256()));\n    }\n\n    /**\n     * @dev Sets `account`'s Internal Balance for `token` to `newBalance`.\n     *\n     * Emits an `InternalBalanceChanged` event. This event includes `delta`, which is the amount the balance increased\n     * (if positive) or decreased (if negative). To avoid reading the current balance in order to compute the delta,\n     * this function relies on the caller providing it directly.\n     */\n    function _setInternalBalance(\n        address account,\n        IERC20 token,\n        uint256 newBalance,\n        int256 delta\n    ) private {\n        _internalTokenBalance[account][token] = newBalance;\n        emit InternalBalanceChanged(account, token, delta);\n    }\n\n    /**\n     * @dev Returns `account`'s Internal Balance for `token`.\n     */\n    function _getInternalBalance(address account, IERC20 token) internal view returns (uint256) {\n        return _internalTokenBalance[account][token];\n    }\n\n    /**\n     * @dev Destructures a User Balance operation, validating that the contract caller is allowed to perform it.\n     */\n    function _validateUserBalanceOp(UserBalanceOp memory op, bool checkedCallerIsRelayer)\n        private\n        view\n        returns (\n            UserBalanceOpKind,\n            IAsset,\n            uint256,\n            address,\n            address payable,\n            bool\n        )\n    {\n        // The only argument we need to validate is `sender`, which can only be either the contract caller, or a\n        // relayer approved by `sender`.\n        address sender = op.sender;\n\n        if (sender != msg.sender) {\n            // We need to check both that the contract caller is a relayer, and that `sender` approved them.\n\n            // Because the relayer check is global (i.e. independent of `sender`), we cache that result and skip it for\n            // other operations in this same transaction (if any).\n            if (!checkedCallerIsRelayer) {\n                _authenticateCaller();\n                checkedCallerIsRelayer = true;\n            }\n\n            _require(_hasApprovedRelayer(sender, msg.sender), Errors.USER_DOESNT_ALLOW_RELAYER);\n        }\n\n        return (op.kind, op.asset, op.amount, sender, op.recipient, checkedCallerIsRelayer);\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/PoolTokens.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\n\nimport \"./AssetManagers.sol\";\nimport \"./PoolRegistry.sol\";\nimport \"./balances/BalanceAllocation.sol\";\n\nabstract contract PoolTokens is ReentrancyGuard, PoolRegistry, AssetManagers {\n    using BalanceAllocation for bytes32;\n    using BalanceAllocation for bytes32[];\n\n    function registerTokens(\n        bytes32 poolId,\n        IERC20[] memory tokens,\n        address[] memory assetManagers\n    ) external override nonReentrant whenNotPaused onlyPool(poolId) {\n        InputHelpers.ensureInputLengthMatch(tokens.length, assetManagers.length);\n\n        // Validates token addresses and assigns Asset Managers\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            IERC20 token = tokens[i];\n            _require(token != IERC20(0), Errors.INVALID_TOKEN);\n\n            _poolAssetManagers[poolId][token] = assetManagers[i];\n        }\n\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            _require(tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2);\n            _registerTwoTokenPoolTokens(poolId, tokens[0], tokens[1]);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            _registerMinimalSwapInfoPoolTokens(poolId, tokens);\n        } else {\n            // PoolSpecialization.GENERAL\n            _registerGeneralPoolTokens(poolId, tokens);\n        }\n\n        emit TokensRegistered(poolId, tokens, assetManagers);\n    }\n\n    function deregisterTokens(bytes32 poolId, IERC20[] memory tokens)\n        external\n        override\n        nonReentrant\n        whenNotPaused\n        onlyPool(poolId)\n    {\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            _require(tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2);\n            _deregisterTwoTokenPoolTokens(poolId, tokens[0], tokens[1]);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            _deregisterMinimalSwapInfoPoolTokens(poolId, tokens);\n        } else {\n            // PoolSpecialization.GENERAL\n            _deregisterGeneralPoolTokens(poolId, tokens);\n        }\n\n        // The deregister calls above ensure the total token balance is zero. Therefore it is now safe to remove any\n        // associated Asset Managers, since they hold no Pool balance.\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            delete _poolAssetManagers[poolId][tokens[i]];\n        }\n\n        emit TokensDeregistered(poolId, tokens);\n    }\n\n    function getPoolTokens(bytes32 poolId)\n        external\n        view\n        override\n        withRegisteredPool(poolId)\n        returns (\n            IERC20[] memory tokens,\n            uint256[] memory balances,\n            uint256 lastChangeBlock\n        )\n    {\n        bytes32[] memory rawBalances;\n        (tokens, rawBalances) = _getPoolTokens(poolId);\n        (balances, lastChangeBlock) = rawBalances.totalsAndLastChangeBlock();\n    }\n\n    function getPoolTokenInfo(bytes32 poolId, IERC20 token)\n        external\n        view\n        override\n        withRegisteredPool(poolId)\n        returns (\n            uint256 cash,\n            uint256 managed,\n            uint256 lastChangeBlock,\n            address assetManager\n        )\n    {\n        bytes32 balance;\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            balance = _getTwoTokenPoolBalance(poolId, token);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            balance = _getMinimalSwapInfoPoolBalance(poolId, token);\n        } else {\n            // PoolSpecialization.GENERAL\n            balance = _getGeneralPoolBalance(poolId, token);\n        }\n\n        cash = balance.cash();\n        managed = balance.managed();\n        lastChangeBlock = balance.lastChangeBlock();\n        assetManager = _poolAssetManagers[poolId][token];\n    }\n\n    /**\n     * @dev Returns all of `poolId`'s registered tokens, along with their raw balances.\n     */\n    function _getPoolTokens(bytes32 poolId) internal view returns (IERC20[] memory tokens, bytes32[] memory balances) {\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            return _getTwoTokenPoolTokens(poolId);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            return _getMinimalSwapInfoPoolTokens(poolId);\n        } else {\n            // PoolSpecialization.GENERAL\n            return _getGeneralPoolTokens(poolId);\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeCast.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\n * checks.\n *\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\n * easily result in undesired exploitation or bugs, since developers usually\n * assume that overflows raise errors. `SafeCast` restores this intuition by\n * reverting the transaction when such an operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n *\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\n * all math on `uint256` and `int256` and then downcasting.\n */\nlibrary SafeCast {\n    /**\n     * @dev Converts an unsigned uint256 into a signed int256.\n     *\n     * Requirements:\n     *\n     * - input must be less than or equal to maxInt256.\n     */\n    function toInt256(uint256 value) internal pure returns (int256) {\n        _require(value < 2**255, Errors.SAFE_CAST_VALUE_CANT_FIT_INT256);\n        return int256(value);\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/AssetTransfersHandler.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/misc/IWETH.sol\";\n\nimport \"./interfaces/IAsset.sol\";\nimport \"./interfaces/IVault.sol\";\n\nimport \"./AssetHelpers.sol\";\n\nabstract contract AssetTransfersHandler is AssetHelpers {\n    using SafeERC20 for IERC20;\n    using Address for address payable;\n\n    /**\n     * @dev Receives `amount` of `asset` from `sender`. If `fromInternalBalance` is true, it first withdraws as much\n     * as possible from Internal Balance, then transfers any remaining amount.\n     *\n     * If `asset` is ETH, `fromInternalBalance` must be false (as ETH cannot be held as internal balance), and the funds\n     * will be wrapped into WETH.\n     *\n     * WARNING: this function does not check that the contract caller has actually supplied any ETH - it is up to the\n     * caller of this function to check that this is true to prevent the Vault from using its own ETH (though the Vault\n     * typically doesn't hold any).\n     */\n    function _receiveAsset(\n        IAsset asset,\n        uint256 amount,\n        address sender,\n        bool fromInternalBalance\n    ) internal {\n        if (amount == 0) {\n            return;\n        }\n\n        if (_isETH(asset)) {\n            _require(!fromInternalBalance, Errors.INVALID_ETH_INTERNAL_BALANCE);\n\n            // The ETH amount to receive is deposited into the WETH contract, which will in turn mint WETH for\n            // the Vault at a 1:1 ratio.\n\n            // A check for this condition is also introduced by the compiler, but this one provides a revert reason.\n            // Note we're checking for the Vault's total balance, *not* ETH sent in this transaction.\n            _require(address(this).balance >= amount, Errors.INSUFFICIENT_ETH);\n            _WETH().deposit{ value: amount }();\n        } else {\n            IERC20 token = _asIERC20(asset);\n\n            if (fromInternalBalance) {\n                // We take as many tokens from Internal Balance as possible: any remaining amounts will be transferred.\n                uint256 deductedBalance = _decreaseInternalBalance(sender, token, amount, true);\n                // Because `deductedBalance` will be always the lesser of the current internal balance\n                // and the amount to decrease, it is safe to perform unchecked arithmetic.\n                amount -= deductedBalance;\n            }\n\n            if (amount > 0) {\n                token.safeTransferFrom(sender, address(this), amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Sends `amount` of `asset` to `recipient`. If `toInternalBalance` is true, the asset is deposited as Internal\n     * Balance instead of being transferred.\n     *\n     * If `asset` is ETH, `toInternalBalance` must be false (as ETH cannot be held as internal balance), and the funds\n     * are instead sent directly after unwrapping WETH.\n     */\n    function _sendAsset(\n        IAsset asset,\n        uint256 amount,\n        address payable recipient,\n        bool toInternalBalance\n    ) internal {\n        if (amount == 0) {\n            return;\n        }\n\n        if (_isETH(asset)) {\n            // Sending ETH is not as involved as receiving it: the only special behavior is it cannot be\n            // deposited to Internal Balance.\n            _require(!toInternalBalance, Errors.INVALID_ETH_INTERNAL_BALANCE);\n\n            // First, the Vault withdraws deposited ETH from the WETH contract, by burning the same amount of WETH\n            // from the Vault. This receipt will be handled by the Vault's `receive`.\n            _WETH().withdraw(amount);\n\n            // Then, the withdrawn ETH is sent to the recipient.\n            recipient.sendValue(amount);\n        } else {\n            IERC20 token = _asIERC20(asset);\n            if (toInternalBalance) {\n                _increaseInternalBalance(recipient, token, amount);\n            } else {\n                token.safeTransfer(recipient, amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Returns excess ETH back to the contract caller, assuming `amountUsed` has been spent. Reverts\n     * if the caller sent less ETH than `amountUsed`.\n     *\n     * Because the caller might not know exactly how much ETH a Vault action will require, they may send extra.\n     * Note that this excess value is returned *to the contract caller* (msg.sender). If caller and e.g. swap sender are\n     * not the same (because the caller is a relayer for the sender), then it is up to the caller to manage this\n     * returned ETH.\n     */\n    function _handleRemainingEth(uint256 amountUsed) internal {\n        _require(msg.value >= amountUsed, Errors.INSUFFICIENT_ETH);\n\n        uint256 excess = msg.value - amountUsed;\n        if (excess > 0) {\n            msg.sender.sendValue(excess);\n        }\n    }\n\n    /**\n     * @dev Enables the Vault to receive ETH. This is required for it to be able to unwrap WETH, which sends ETH to the\n     * caller.\n     *\n     * Any ETH sent to the Vault outside of the WETH unwrapping mechanism would be forever locked inside the Vault, so\n     * we prevent that from happening. Other mechanisms used to send ETH to the Vault (such as being the recipient of an\n     * ETH swap, Pool exit or withdrawal, contract self-destruction, or receiving the block mining reward) will result\n     * in locked funds, but are not otherwise a security or soundness issue. This check only exists as an attempt to\n     * prevent user error.\n     */\n    receive() external payable {\n        _require(msg.sender == address(_WETH()), Errors.ETH_TRANSFER);\n    }\n\n    // This contract uses virtual internal functions instead of inheriting from the modules that implement them (in\n    // this case UserBalance) in order to decouple it from the rest of the system and enable standalone testing by\n    // implementing these with mocks.\n\n    function _increaseInternalBalance(\n        address account,\n        IERC20 token,\n        uint256 amount\n    ) internal virtual;\n\n    function _decreaseInternalBalance(\n        address account,\n        IERC20 token,\n        uint256 amount,\n        bool capped\n    ) internal virtual returns (uint256);\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/AssetHelpers.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/misc/IWETH.sol\";\n\nimport \"./interfaces/IAsset.sol\";\n\nabstract contract AssetHelpers {\n    // solhint-disable-next-line var-name-mixedcase\n    IWETH private immutable _weth;\n\n    // Sentinel value used to indicate WETH with wrapping/unwrapping semantics. The zero address is a good choice for\n    // multiple reasons: it is cheap to pass as a calldata argument, it is a known invalid token and non-contract, and\n    // it is an address Pools cannot register as a token.\n    address private constant _ETH = address(0);\n\n    constructor(IWETH weth) {\n        _weth = weth;\n    }\n\n    // solhint-disable-next-line func-name-mixedcase\n    function _WETH() internal view returns (IWETH) {\n        return _weth;\n    }\n\n    /**\n     * @dev Returns true if `asset` is the sentinel value that represents ETH.\n     */\n    function _isETH(IAsset asset) internal pure returns (bool) {\n        return address(asset) == _ETH;\n    }\n\n    /**\n     * @dev Translates `asset` into an equivalent IERC20 token address. If `asset` represents ETH, it will be translated\n     * to the WETH contract.\n     */\n    function _translateToIERC20(IAsset asset) internal view returns (IERC20) {\n        return _isETH(asset) ? _WETH() : _asIERC20(asset);\n    }\n\n    /**\n     * @dev Same as `_translateToIERC20(IAsset)`, but for an entire array.\n     */\n    function _translateToIERC20(IAsset[] memory assets) internal view returns (IERC20[] memory) {\n        IERC20[] memory tokens = new IERC20[](assets.length);\n        for (uint256 i = 0; i < assets.length; ++i) {\n            tokens[i] = _translateToIERC20(assets[i]);\n        }\n        return tokens;\n    }\n\n    /**\n     * @dev Interprets `asset` as an IERC20 token. This function should only be called on `asset` if `_isETH` previously\n     * returned false for it, that is, if `asset` is guaranteed not to be the ETH sentinel value.\n     */\n    function _asIERC20(IAsset asset) internal pure returns (IERC20) {\n        return IERC20(address(asset));\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/Address.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            size := extcodesize(account)\n        }\n        return size > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        _require(address(this).balance >= amount, Errors.ADDRESS_INSUFFICIENT_BALANCE);\n\n        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n        (bool success, ) = recipient.call{ value: amount }(\"\");\n        _require(success, Errors.ADDRESS_CANNOT_SEND_VALUE);\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        _require(isContract(target), Errors.CALL_TO_NON_CONTRACT);\n\n        (bool success, bytes memory returndata) = target.call(data);\n        return verifyCallResult(success, returndata);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n                // solhint-disable-next-line no-inline-assembly\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                _revert(Errors.LOW_LEVEL_CALL_FAILED);\n            }\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/balances/BalanceAllocation.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\n\n// This library is used to create a data structure that represents a token's balance for a Pool. 'cash' is how many\n// tokens the Pool has sitting inside of the Vault. 'managed' is how many tokens were withdrawn from the Vault by the\n// Pool's Asset Manager. 'total' is the sum of these two, and represents the Pool's total token balance, including\n// tokens that are *not* inside of the Vault.\n//\n// 'cash' is updated whenever tokens enter and exit the Vault, while 'managed' is only updated if the reason tokens are\n// moving is due to an Asset Manager action. This is reflected in the different methods available: 'increaseCash'\n// and 'decreaseCash' for swaps and add/remove liquidity events, and 'cashToManaged' and 'managedToCash' for events\n// transferring funds to and from the Asset Manager.\n//\n// The Vault disallows the Pool's 'cash' from becoming negative. In other words, it can never use any tokens that are\n// not inside the Vault.\n//\n// One of the goals of this library is to store the entire token balance in a single storage slot, which is why we use\n// 112 bit unsigned integers for 'cash' and 'managed'. For consistency, we also disallow any combination of 'cash' and\n// 'managed' that yields a 'total' that doesn't fit in 112 bits.\n//\n// The remaining 32 bits of the slot are used to store the most recent block when the total balance changed. This\n// can be used to implement price oracles that are resilient to 'sandwich' attacks.\n//\n// We could use a Solidity struct to pack these three values together in a single storage slot, but unfortunately\n// Solidity only allows for structs to live in either storage, calldata or memory. Because a memory struct still takes\n// up a slot in the stack (to store its memory location), and because the entire balance fits in a single stack slot\n// (two 112 bit values plus the 32 bit block), using memory is strictly less gas performant. Therefore, we do manual\n// packing and unpacking.\n//\n// Since we cannot define new types, we rely on bytes32 to represent these values instead, as it doesn't have any\n// associated arithmetic operations and therefore reduces the chance of misuse.\nlibrary BalanceAllocation {\n    using Math for uint256;\n\n    // The 'cash' portion of the balance is stored in the least significant 112 bits of a 256 bit word, while the\n    // 'managed' part uses the following 112 bits. The most significant 32 bits are used to store the block\n\n    /**\n     * @dev Returns the total amount of Pool tokens, including those that are not currently in the Vault ('managed').\n     */\n    function total(bytes32 balance) internal pure returns (uint256) {\n        // Since 'cash' and 'managed' are 112 bit values, we don't need checked arithmetic. Additionally, `toBalance`\n        // ensures that 'total' always fits in 112 bits.\n        return cash(balance) + managed(balance);\n    }\n\n    /**\n     * @dev Returns the amount of Pool tokens currently in the Vault.\n     */\n    function cash(bytes32 balance) internal pure returns (uint256) {\n        uint256 mask = 2**(112) - 1;\n        return uint256(balance) & mask;\n    }\n\n    /**\n     * @dev Returns the amount of Pool tokens that are being managed by an Asset Manager.\n     */\n    function managed(bytes32 balance) internal pure returns (uint256) {\n        uint256 mask = 2**(112) - 1;\n        return uint256(balance >> 112) & mask;\n    }\n\n    /**\n     * @dev Returns the last block when the total balance changed.\n     */\n    function lastChangeBlock(bytes32 balance) internal pure returns (uint256) {\n        uint256 mask = 2**(32) - 1;\n        return uint256(balance >> 224) & mask;\n    }\n\n    /**\n     * @dev Returns the difference in 'managed' between two balances.\n     */\n    function managedDelta(bytes32 newBalance, bytes32 oldBalance) internal pure returns (int256) {\n        // Because `managed` is a 112 bit value, we can safely perform unchecked arithmetic in 256 bits.\n        return int256(managed(newBalance)) - int256(managed(oldBalance));\n    }\n\n    /**\n     * @dev Returns the total balance for each entry in `balances`, as well as the latest block when the total\n     * balance of *any* of them last changed.\n     */\n    function totalsAndLastChangeBlock(bytes32[] memory balances)\n        internal\n        pure\n        returns (\n            uint256[] memory results,\n            uint256 lastChangeBlock_ // Avoid shadowing\n        )\n    {\n        results = new uint256[](balances.length);\n        lastChangeBlock_ = 0;\n\n        for (uint256 i = 0; i < results.length; i++) {\n            bytes32 balance = balances[i];\n            results[i] = total(balance);\n            lastChangeBlock_ = Math.max(lastChangeBlock_, lastChangeBlock(balance));\n        }\n    }\n\n    /**\n     * @dev Returns true if `balance`'s 'total' balance is zero. Costs less gas than computing 'total' and comparing\n     * with zero.\n     */\n    function isZero(bytes32 balance) internal pure returns (bool) {\n        // We simply need to check the least significant 224 bytes of the word: the block does not affect this.\n        uint256 mask = 2**(224) - 1;\n        return (uint256(balance) & mask) == 0;\n    }\n\n    /**\n     * @dev Returns true if `balance`'s 'total' balance is not zero. Costs less gas than computing 'total' and comparing\n     * with zero.\n     */\n    function isNotZero(bytes32 balance) internal pure returns (bool) {\n        return !isZero(balance);\n    }\n\n    /**\n     * @dev Packs together `cash` and `managed` amounts with a block to create a balance value.\n     *\n     * For consistency, this also checks that the sum of `cash` and `managed` (`total`) fits in 112 bits.\n     */\n    function toBalance(\n        uint256 _cash,\n        uint256 _managed,\n        uint256 _blockNumber\n    ) internal pure returns (bytes32) {\n        uint256 _total = _cash + _managed;\n\n        // Since both 'cash' and 'managed' are positive integers, by checking that their sum ('total') fits in 112 bits\n        // we are also indirectly checking that both 'cash' and 'managed' themselves fit in 112 bits.\n        _require(_total >= _cash && _total < 2**112, Errors.BALANCE_TOTAL_OVERFLOW);\n\n        // We assume the block fits in 32 bits - this is expected to hold for at least a few decades.\n        return _pack(_cash, _managed, _blockNumber);\n    }\n\n    /**\n     * @dev Increases a Pool's 'cash' (and therefore its 'total'). Called when Pool tokens are sent to the Vault (except\n     * for Asset Manager deposits).\n     *\n     * Updates the last total balance change block, even if `amount` is zero.\n     */\n    function increaseCash(bytes32 balance, uint256 amount) internal view returns (bytes32) {\n        uint256 newCash = cash(balance).add(amount);\n        uint256 currentManaged = managed(balance);\n        uint256 newLastChangeBlock = block.number;\n\n        return toBalance(newCash, currentManaged, newLastChangeBlock);\n    }\n\n    /**\n     * @dev Decreases a Pool's 'cash' (and therefore its 'total'). Called when Pool tokens are sent from the Vault\n     * (except for Asset Manager withdrawals).\n     *\n     * Updates the last total balance change block, even if `amount` is zero.\n     */\n    function decreaseCash(bytes32 balance, uint256 amount) internal view returns (bytes32) {\n        uint256 newCash = cash(balance).sub(amount);\n        uint256 currentManaged = managed(balance);\n        uint256 newLastChangeBlock = block.number;\n\n        return toBalance(newCash, currentManaged, newLastChangeBlock);\n    }\n\n    /**\n     * @dev Moves 'cash' into 'managed', leaving 'total' unchanged. Called when an Asset Manager withdraws Pool tokens\n     * from the Vault.\n     */\n    function cashToManaged(bytes32 balance, uint256 amount) internal pure returns (bytes32) {\n        uint256 newCash = cash(balance).sub(amount);\n        uint256 newManaged = managed(balance).add(amount);\n        uint256 currentLastChangeBlock = lastChangeBlock(balance);\n\n        return toBalance(newCash, newManaged, currentLastChangeBlock);\n    }\n\n    /**\n     * @dev Moves 'managed' into 'cash', leaving 'total' unchanged. Called when an Asset Manager deposits Pool tokens\n     * into the Vault.\n     */\n    function managedToCash(bytes32 balance, uint256 amount) internal pure returns (bytes32) {\n        uint256 newCash = cash(balance).add(amount);\n        uint256 newManaged = managed(balance).sub(amount);\n        uint256 currentLastChangeBlock = lastChangeBlock(balance);\n\n        return toBalance(newCash, newManaged, currentLastChangeBlock);\n    }\n\n    /**\n     * @dev Sets 'managed' balance to an arbitrary value, changing 'total'. Called when the Asset Manager reports\n     * profits or losses. It's the Manager's responsibility to provide a meaningful value.\n     *\n     * Updates the last total balance change block, even if `newManaged` is equal to the current 'managed' value.\n     */\n    function setManaged(bytes32 balance, uint256 newManaged) internal view returns (bytes32) {\n        uint256 currentCash = cash(balance);\n        uint256 newLastChangeBlock = block.number;\n        return toBalance(currentCash, newManaged, newLastChangeBlock);\n    }\n\n    // Alternative mode for Pools with the Two Token specialization setting\n\n    // Instead of storing cash and external for each 'token in' a single storage slot, Two Token Pools store the cash\n    // for both tokens in the same slot, and the managed for both in another one. This reduces the gas cost for swaps,\n    // because the only slot that needs to be updated is the one with the cash. However, it also means that managing\n    // balances is more cumbersome, as both tokens need to be read/written at the same time.\n    //\n    // The field with both cash balances packed is called sharedCash, and the one with external amounts is called\n    // sharedManaged. These two are collectively called the 'shared' balance fields. In both of these, the portion\n    // that corresponds to token A is stored in the least significant 112 bits of a 256 bit word, while token B's part\n    // uses the next least significant 112 bits.\n    //\n    // Because only cash is written to during a swap, we store the last total balance change block with the\n    // packed cash fields. Typically Pools have a distinct block per token: in the case of Two Token Pools they\n    // are the same.\n\n    /**\n     * @dev Extracts the part of the balance that corresponds to token A. This function can be used to decode both\n     * shared cash and managed balances.\n     */\n    function _decodeBalanceA(bytes32 sharedBalance) private pure returns (uint256) {\n        uint256 mask = 2**(112) - 1;\n        return uint256(sharedBalance) & mask;\n    }\n\n    /**\n     * @dev Extracts the part of the balance that corresponds to token B. This function can be used to decode both\n     * shared cash and managed balances.\n     */\n    function _decodeBalanceB(bytes32 sharedBalance) private pure returns (uint256) {\n        uint256 mask = 2**(112) - 1;\n        return uint256(sharedBalance >> 112) & mask;\n    }\n\n    // To decode the last balance change block, we can simply use the `blockNumber` function.\n\n    /**\n     * @dev Unpacks the shared token A and token B cash and managed balances into the balance for token A.\n     */\n    function fromSharedToBalanceA(bytes32 sharedCash, bytes32 sharedManaged) internal pure returns (bytes32) {\n        // Note that we extract the block from the sharedCash field, which is the one that is updated by swaps.\n        // Both token A and token B use the same block\n        return toBalance(_decodeBalanceA(sharedCash), _decodeBalanceA(sharedManaged), lastChangeBlock(sharedCash));\n    }\n\n    /**\n     * @dev Unpacks the shared token A and token B cash and managed balances into the balance for token B.\n     */\n    function fromSharedToBalanceB(bytes32 sharedCash, bytes32 sharedManaged) internal pure returns (bytes32) {\n        // Note that we extract the block from the sharedCash field, which is the one that is updated by swaps.\n        // Both token A and token B use the same block\n        return toBalance(_decodeBalanceB(sharedCash), _decodeBalanceB(sharedManaged), lastChangeBlock(sharedCash));\n    }\n\n    /**\n     * @dev Returns the sharedCash shared field, given the current balances for token A and token B.\n     */\n    function toSharedCash(bytes32 tokenABalance, bytes32 tokenBBalance) internal pure returns (bytes32) {\n        // Both balances are assigned the same block  Since it is possible a single one of them has changed (for\n        // example, in an Asset Manager update), we keep the latest (largest) one.\n        uint32 newLastChangeBlock = uint32(Math.max(lastChangeBlock(tokenABalance), lastChangeBlock(tokenBBalance)));\n\n        return _pack(cash(tokenABalance), cash(tokenBBalance), newLastChangeBlock);\n    }\n\n    /**\n     * @dev Returns the sharedManaged shared field, given the current balances for token A and token B.\n     */\n    function toSharedManaged(bytes32 tokenABalance, bytes32 tokenBBalance) internal pure returns (bytes32) {\n        // We don't bother storing a last change block, as it is read from the shared cash field.\n        return _pack(managed(tokenABalance), managed(tokenBBalance), 0);\n    }\n\n    // Shared functions\n\n    /**\n     * @dev Packs together two uint112 and one uint32 into a bytes32\n     */\n    function _pack(\n        uint256 _leastSignificant,\n        uint256 _midSignificant,\n        uint256 _mostSignificant\n    ) private pure returns (bytes32) {\n        return bytes32((_mostSignificant << 224) + (_midSignificant << 112) + _leastSignificant);\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/PoolRegistry.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\n\nimport \"./VaultAuthorization.sol\";\n\n/**\n * @dev Maintains the Pool ID data structure, implements Pool ID creation and registration, and defines useful modifiers\n * and helper functions for ensuring correct behavior when working with Pools.\n */\nabstract contract PoolRegistry is ReentrancyGuard, VaultAuthorization {\n    // Each pool is represented by their unique Pool ID. We use `bytes32` for them, for lack of a way to define new\n    // types.\n    mapping(bytes32 => bool) private _isPoolRegistered;\n\n    // We keep an increasing nonce to make Pool IDs unique. It is interpreted as a `uint80`, but storing it as a\n    // `uint256` results in reduced bytecode on reads and writes due to the lack of masking.\n    uint256 private _nextPoolNonce;\n\n    /**\n     * @dev Reverts unless `poolId` corresponds to a registered Pool.\n     */\n    modifier withRegisteredPool(bytes32 poolId) {\n        _ensureRegisteredPool(poolId);\n        _;\n    }\n\n    /**\n     * @dev Reverts unless `poolId` corresponds to a registered Pool, and the caller is the Pool's contract.\n     */\n    modifier onlyPool(bytes32 poolId) {\n        _ensurePoolIsSender(poolId);\n        _;\n    }\n\n    /**\n     * @dev Reverts unless `poolId` corresponds to a registered Pool.\n     */\n    function _ensureRegisteredPool(bytes32 poolId) internal view {\n        _require(_isPoolRegistered[poolId], Errors.INVALID_POOL_ID);\n    }\n\n    /**\n     * @dev Reverts unless `poolId` corresponds to a registered Pool, and the caller is the Pool's contract.\n     */\n    function _ensurePoolIsSender(bytes32 poolId) private view {\n        _ensureRegisteredPool(poolId);\n        _require(msg.sender == _getPoolAddress(poolId), Errors.CALLER_NOT_POOL);\n    }\n\n    function registerPool(PoolSpecialization specialization)\n        external\n        override\n        nonReentrant\n        whenNotPaused\n        returns (bytes32)\n    {\n        // Each Pool is assigned a unique ID based on an incrementing nonce. This assumes there will never be more than\n        // 2**80 Pools, and the nonce will not overflow.\n\n        bytes32 poolId = _toPoolId(msg.sender, specialization, uint80(_nextPoolNonce));\n\n        _require(!_isPoolRegistered[poolId], Errors.INVALID_POOL_ID); // Should never happen as Pool IDs are unique.\n        _isPoolRegistered[poolId] = true;\n\n        _nextPoolNonce += 1;\n\n        // Note that msg.sender is the pool's contract\n        emit PoolRegistered(poolId, msg.sender, specialization);\n        return poolId;\n    }\n\n    function getPool(bytes32 poolId)\n        external\n        view\n        override\n        withRegisteredPool(poolId)\n        returns (address, PoolSpecialization)\n    {\n        return (_getPoolAddress(poolId), _getPoolSpecialization(poolId));\n    }\n\n    /**\n     * @dev Creates a Pool ID.\n     *\n     * These are deterministically created by packing the Pool's contract address and its specialization setting into\n     * the ID. This saves gas by making this data easily retrievable from a Pool ID with no storage accesses.\n     *\n     * Since a single contract can register multiple Pools, a unique nonce must be provided to ensure Pool IDs are\n     * unique.\n     *\n     * Pool IDs have the following layout:\n     * | 20 bytes pool contract address | 2 bytes specialization setting | 10 bytes nonce |\n     * MSB                                                                              LSB\n     *\n     * 2 bytes for the specialization setting is a bit overkill: there only three of them, which means two bits would\n     * suffice. However, there's nothing else of interest to store in this extra space.\n     */\n    function _toPoolId(\n        address pool,\n        PoolSpecialization specialization,\n        uint80 nonce\n    ) internal pure returns (bytes32) {\n        bytes32 serialized;\n\n        serialized |= bytes32(uint256(nonce));\n        serialized |= bytes32(uint256(specialization)) << (10 * 8);\n        serialized |= bytes32(uint256(pool)) << (12 * 8);\n\n        return serialized;\n    }\n\n    /**\n     * @dev Returns the address of a Pool's contract.\n     *\n     * Due to how Pool IDs are created, this is done with no storage accesses and costs little gas.\n     */\n    function _getPoolAddress(bytes32 poolId) internal pure returns (address) {\n        // 12 byte logical shift left to remove the nonce and specialization setting. We don't need to mask,\n        // since the logical shift already sets the upper bits to zero.\n        return address(uint256(poolId) >> (12 * 8));\n    }\n\n    /**\n     * @dev Returns the specialization setting of a Pool.\n     *\n     * Due to how Pool IDs are created, this is done with no storage accesses and costs little gas.\n     */\n    function _getPoolSpecialization(bytes32 poolId) internal pure returns (PoolSpecialization specialization) {\n        // 10 byte logical shift left to remove the nonce, followed by a 2 byte mask to remove the address.\n        uint256 value = uint256(poolId >> (10 * 8)) & (2**(2 * 8) - 1);\n\n        // Casting a value into an enum results in a runtime check that reverts unless the value is within the enum's\n        // range. Passing an invalid Pool ID to this function would then result in an obscure revert with no reason\n        // string: we instead perform the check ourselves to help in error diagnosis.\n\n        // There are three Pool specialization settings: general, minimal swap info and two tokens, which correspond to\n        // values 0, 1 and 2.\n        _require(value < 3, Errors.INVALID_POOL_ID);\n\n        // Because we have checked that `value` is within the enum range, we can use assembly to skip the runtime check.\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            specialization := value\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/AssetManagers.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\n\nimport \"./UserBalance.sol\";\nimport \"./balances/BalanceAllocation.sol\";\nimport \"./balances/GeneralPoolsBalance.sol\";\nimport \"./balances/MinimalSwapInfoPoolsBalance.sol\";\nimport \"./balances/TwoTokenPoolsBalance.sol\";\n\nabstract contract AssetManagers is\n    ReentrancyGuard,\n    GeneralPoolsBalance,\n    MinimalSwapInfoPoolsBalance,\n    TwoTokenPoolsBalance\n{\n    using Math for uint256;\n    using SafeERC20 for IERC20;\n\n    // Stores the Asset Manager for each token of each Pool.\n    mapping(bytes32 => mapping(IERC20 => address)) internal _poolAssetManagers;\n\n    function managePoolBalance(PoolBalanceOp[] memory ops) external override nonReentrant whenNotPaused {\n        // This variable could be declared inside the loop, but that causes the compiler to allocate memory on each\n        // loop iteration, increasing gas costs.\n        PoolBalanceOp memory op;\n\n        for (uint256 i = 0; i < ops.length; ++i) {\n            // By indexing the array only once, we don't spend extra gas in the same bounds check.\n            op = ops[i];\n\n            bytes32 poolId = op.poolId;\n            _ensureRegisteredPool(poolId);\n\n            IERC20 token = op.token;\n            _require(_isTokenRegistered(poolId, token), Errors.TOKEN_NOT_REGISTERED);\n            _require(_poolAssetManagers[poolId][token] == msg.sender, Errors.SENDER_NOT_ASSET_MANAGER);\n\n            PoolBalanceOpKind kind = op.kind;\n            uint256 amount = op.amount;\n            (int256 cashDelta, int256 managedDelta) = _performPoolManagementOperation(kind, poolId, token, amount);\n\n            emit PoolBalanceManaged(poolId, msg.sender, token, cashDelta, managedDelta);\n        }\n    }\n\n    /**\n     * @dev Performs the `kind` Asset Manager operation on a Pool.\n     *\n     * Withdrawals will transfer `amount` tokens to the caller, deposits will transfer `amount` tokens from the caller,\n     * and updates will set the managed balance to `amount`.\n     *\n     * Returns a tuple with the 'cash' and 'managed' balance deltas as a result of this call.\n     */\n    function _performPoolManagementOperation(\n        PoolBalanceOpKind kind,\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) private returns (int256, int256) {\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n\n        if (kind == PoolBalanceOpKind.WITHDRAW) {\n            return _withdrawPoolBalance(poolId, specialization, token, amount);\n        } else if (kind == PoolBalanceOpKind.DEPOSIT) {\n            return _depositPoolBalance(poolId, specialization, token, amount);\n        } else {\n            // PoolBalanceOpKind.UPDATE\n            return _updateManagedBalance(poolId, specialization, token, amount);\n        }\n    }\n\n    /**\n     * @dev Moves `amount` tokens from a Pool's 'cash' to 'managed' balance, and transfers them to the caller.\n     *\n     * Returns the 'cash' and 'managed' balance deltas as a result of this call, which will be complementary.\n     */\n    function _withdrawPoolBalance(\n        bytes32 poolId,\n        PoolSpecialization specialization,\n        IERC20 token,\n        uint256 amount\n    ) private returns (int256 cashDelta, int256 managedDelta) {\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            _twoTokenPoolCashToManaged(poolId, token, amount);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            _minimalSwapInfoPoolCashToManaged(poolId, token, amount);\n        } else {\n            // PoolSpecialization.GENERAL\n            _generalPoolCashToManaged(poolId, token, amount);\n        }\n\n        if (amount > 0) {\n            token.safeTransfer(msg.sender, amount);\n        }\n\n        // Since 'cash' and 'managed' are stored as uint112, `amount` is guaranteed to also fit in 112 bits. It will\n        // therefore always fit in a 256 bit integer.\n        cashDelta = int256(-amount);\n        managedDelta = int256(amount);\n    }\n\n    /**\n     * @dev Moves `amount` tokens from a Pool's 'managed' to 'cash' balance, and transfers them from the caller.\n     *\n     * Returns the 'cash' and 'managed' balance deltas as a result of this call, which will be complementary.\n     */\n    function _depositPoolBalance(\n        bytes32 poolId,\n        PoolSpecialization specialization,\n        IERC20 token,\n        uint256 amount\n    ) private returns (int256 cashDelta, int256 managedDelta) {\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            _twoTokenPoolManagedToCash(poolId, token, amount);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            _minimalSwapInfoPoolManagedToCash(poolId, token, amount);\n        } else {\n            // PoolSpecialization.GENERAL\n            _generalPoolManagedToCash(poolId, token, amount);\n        }\n\n        if (amount > 0) {\n            token.safeTransferFrom(msg.sender, address(this), amount);\n        }\n\n        // Since 'cash' and 'managed' are stored as uint112, `amount` is guaranteed to also fit in 112 bits. It will\n        // therefore always fit in a 256 bit integer.\n        cashDelta = int256(amount);\n        managedDelta = int256(-amount);\n    }\n\n    /**\n     * @dev Sets a Pool's 'managed' balance to `amount`.\n     *\n     * Returns the 'cash' and 'managed' balance deltas as a result of this call (the 'cash' delta will always be zero).\n     */\n    function _updateManagedBalance(\n        bytes32 poolId,\n        PoolSpecialization specialization,\n        IERC20 token,\n        uint256 amount\n    ) private returns (int256 cashDelta, int256 managedDelta) {\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            managedDelta = _setTwoTokenPoolManagedBalance(poolId, token, amount);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            managedDelta = _setMinimalSwapInfoPoolManagedBalance(poolId, token, amount);\n        } else {\n            // PoolSpecialization.GENERAL\n            managedDelta = _setGeneralPoolManagedBalance(poolId, token, amount);\n        }\n\n        cashDelta = 0;\n    }\n\n    /**\n     * @dev Returns true if `token` is registered for `poolId`.\n     */\n    function _isTokenRegistered(bytes32 poolId, IERC20 token) private view returns (bool) {\n        PoolSpecialization specialization = _getPoolSpecialization(poolId);\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            return _isTwoTokenPoolTokenRegistered(poolId, token);\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            return _isMinimalSwapInfoPoolTokenRegistered(poolId, token);\n        } else {\n            // PoolSpecialization.GENERAL\n            return _isGeneralPoolTokenRegistered(poolId, token);\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/balances/GeneralPoolsBalance.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableMap.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\nimport \"./BalanceAllocation.sol\";\n\nabstract contract GeneralPoolsBalance {\n    using BalanceAllocation for bytes32;\n    using EnumerableMap for EnumerableMap.IERC20ToBytes32Map;\n\n    // Data for Pools with the General specialization setting\n    //\n    // These Pools use the IGeneralPool interface, which means the Vault must query the balance for *all* of their\n    // tokens in every swap. If we kept a mapping of token to balance plus a set (array) of tokens, it'd be very gas\n    // intensive to read all token addresses just to then do a lookup on the balance mapping.\n    //\n    // Instead, we use our customized EnumerableMap, which lets us read the N balances in N+1 storage accesses (one for\n    // each token in the Pool), access the index of any 'token in' a single read (required for the IGeneralPool call),\n    // and update an entry's value given its index.\n\n    // Map of token -> balance pairs for each Pool with this specialization. Many functions rely on storage pointers to\n    // a Pool's EnumerableMap to save gas when computing storage slots.\n    mapping(bytes32 => EnumerableMap.IERC20ToBytes32Map) internal _generalPoolsBalances;\n\n    /**\n     * @dev Registers a list of tokens in a General Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the General specialization setting.\n     *\n     * Requirements:\n     *\n     * - `tokens` must not be registered in the Pool\n     * - `tokens` must not contain duplicates\n     */\n    function _registerGeneralPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            // EnumerableMaps require an explicit initial value when creating a key-value pair: we use zero, the same\n            // value that is found in uninitialized storage, which corresponds to an empty balance.\n            bool added = poolBalances.set(tokens[i], 0);\n            _require(added, Errors.TOKEN_ALREADY_REGISTERED);\n        }\n    }\n\n    /**\n     * @dev Deregisters a list of tokens in a General Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the General specialization setting.\n     *\n     * Requirements:\n     *\n     * - `tokens` must be registered in the Pool\n     * - `tokens` must have zero balance in the Vault\n     * - `tokens` must not contain duplicates\n     */\n    function _deregisterGeneralPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            IERC20 token = tokens[i];\n            bytes32 currentBalance = _getGeneralPoolBalance(poolBalances, token);\n            _require(currentBalance.isZero(), Errors.NONZERO_TOKEN_BALANCE);\n\n            // We don't need to check remove's return value, since _getGeneralPoolBalance already checks that the token\n            // was registered.\n            poolBalances.remove(token);\n        }\n    }\n\n    /**\n     * @dev Sets the balances of a General Pool's tokens to `balances`.\n     *\n     * WARNING: this assumes `balances` has the same length and order as the Pool's tokens.\n     */\n    function _setGeneralPoolBalances(bytes32 poolId, bytes32[] memory balances) internal {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n\n        for (uint256 i = 0; i < balances.length; ++i) {\n            // Since we assume all balances are properly ordered, we can simply use `unchecked_setAt` to avoid one less\n            // storage read per token.\n            poolBalances.unchecked_setAt(i, balances[i]);\n        }\n    }\n\n    /**\n     * @dev Transforms `amount` of `token`'s balance in a General Pool from cash into managed.\n     *\n     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is\n     * registered for that Pool.\n     */\n    function _generalPoolCashToManaged(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal {\n        _updateGeneralPoolBalance(poolId, token, BalanceAllocation.cashToManaged, amount);\n    }\n\n    /**\n     * @dev Transforms `amount` of `token`'s balance in a General Pool from managed into cash.\n     *\n     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is\n     * registered for that Pool.\n     */\n    function _generalPoolManagedToCash(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal {\n        _updateGeneralPoolBalance(poolId, token, BalanceAllocation.managedToCash, amount);\n    }\n\n    /**\n     * @dev Sets `token`'s managed balance in a General Pool to `amount`.\n     *\n     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is\n     * registered for that Pool.\n     *\n     * Returns the managed balance delta as a result of this call.\n     */\n    function _setGeneralPoolManagedBalance(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal returns (int256) {\n        return _updateGeneralPoolBalance(poolId, token, BalanceAllocation.setManaged, amount);\n    }\n\n    /**\n     * @dev Sets `token`'s balance in a General Pool to the result of the `mutation` function when called with the\n     * current balance and `amount`.\n     *\n     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is\n     * registered for that Pool.\n     *\n     * Returns the managed balance delta as a result of this call.\n     */\n    function _updateGeneralPoolBalance(\n        bytes32 poolId,\n        IERC20 token,\n        function(bytes32, uint256) returns (bytes32) mutation,\n        uint256 amount\n    ) private returns (int256) {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n        bytes32 currentBalance = _getGeneralPoolBalance(poolBalances, token);\n\n        bytes32 newBalance = mutation(currentBalance, amount);\n        poolBalances.set(token, newBalance);\n\n        return newBalance.managedDelta(currentBalance);\n    }\n\n    /**\n     * @dev Returns an array with all the tokens and balances in a General Pool. The order may change when tokens are\n     * registered or deregistered.\n     *\n     * This function assumes `poolId` exists and corresponds to the General specialization setting.\n     */\n    function _getGeneralPoolTokens(bytes32 poolId)\n        internal\n        view\n        returns (IERC20[] memory tokens, bytes32[] memory balances)\n    {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n        tokens = new IERC20[](poolBalances.length());\n        balances = new bytes32[](tokens.length);\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            // Because the iteration is bounded by `tokens.length`, which matches the EnumerableMap's length, we can use\n            // `unchecked_at` as we know `i` is a valid token index, saving storage reads.\n            (tokens[i], balances[i]) = poolBalances.unchecked_at(i);\n        }\n    }\n\n    /**\n     * @dev Returns the balance of a token in a General Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the General specialization setting.\n     *\n     * Requirements:\n     *\n     * - `token` must be registered in the Pool\n     */\n    function _getGeneralPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n        return _getGeneralPoolBalance(poolBalances, token);\n    }\n\n    /**\n     * @dev Same as `_getGeneralPoolBalance` but using a Pool's storage pointer, which saves gas in repeated reads and\n     * writes.\n     */\n    function _getGeneralPoolBalance(EnumerableMap.IERC20ToBytes32Map storage poolBalances, IERC20 token)\n        private\n        view\n        returns (bytes32)\n    {\n        return poolBalances.get(token, Errors.TOKEN_NOT_REGISTERED);\n    }\n\n    /**\n     * @dev Returns true if `token` is registered in a General Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the General specialization setting.\n     */\n    function _isGeneralPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) {\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];\n        return poolBalances.contains(token);\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/balances/MinimalSwapInfoPoolsBalance.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\nimport \"./BalanceAllocation.sol\";\nimport \"../PoolRegistry.sol\";\n\nabstract contract MinimalSwapInfoPoolsBalance is PoolRegistry {\n    using BalanceAllocation for bytes32;\n    using EnumerableSet for EnumerableSet.AddressSet;\n\n    // Data for Pools with the Minimal Swap Info specialization setting\n    //\n    // These Pools use the IMinimalSwapInfoPool interface, and so the Vault must read the balance of the two tokens\n    // in the swap. The best solution is to use a mapping from token to balance, which lets us read or write any token's\n    // balance in a single storage access.\n    //\n    // We also keep a set of registered tokens. Because tokens with non-zero balance are by definition registered, in\n    // some balance getters we skip checking for token registration if a non-zero balance is found, saving gas by\n    // performing a single read instead of two.\n\n    mapping(bytes32 => mapping(IERC20 => bytes32)) internal _minimalSwapInfoPoolsBalances;\n    mapping(bytes32 => EnumerableSet.AddressSet) internal _minimalSwapInfoPoolsTokens;\n\n    /**\n     * @dev Registers a list of tokens in a Minimal Swap Info Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.\n     *\n     * Requirements:\n     *\n     * - `tokens` must not be registered in the Pool\n     * - `tokens` must not contain duplicates\n     */\n    function _registerMinimalSwapInfoPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {\n        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            bool added = poolTokens.add(address(tokens[i]));\n            _require(added, Errors.TOKEN_ALREADY_REGISTERED);\n            // Note that we don't initialize the balance mapping: the default value of zero corresponds to an empty\n            // balance.\n        }\n    }\n\n    /**\n     * @dev Deregisters a list of tokens in a Minimal Swap Info Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.\n     *\n     * Requirements:\n     *\n     * - `tokens` must be registered in the Pool\n     * - `tokens` must have zero balance in the Vault\n     * - `tokens` must not contain duplicates\n     */\n    function _deregisterMinimalSwapInfoPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {\n        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            IERC20 token = tokens[i];\n            _require(_minimalSwapInfoPoolsBalances[poolId][token].isZero(), Errors.NONZERO_TOKEN_BALANCE);\n\n            // For consistency with other Pool specialization settings, we explicitly reset the balance (which may have\n            // a non-zero last change block).\n            delete _minimalSwapInfoPoolsBalances[poolId][token];\n\n            bool removed = poolTokens.remove(address(token));\n            _require(removed, Errors.TOKEN_NOT_REGISTERED);\n        }\n    }\n\n    /**\n     * @dev Sets the balances of a Minimal Swap Info Pool's tokens to `balances`.\n     *\n     * WARNING: this assumes `balances` has the same length and order as the Pool's tokens.\n     */\n    function _setMinimalSwapInfoPoolBalances(\n        bytes32 poolId,\n        IERC20[] memory tokens,\n        bytes32[] memory balances\n    ) internal {\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            _minimalSwapInfoPoolsBalances[poolId][tokens[i]] = balances[i];\n        }\n    }\n\n    /**\n     * @dev Transforms `amount` of `token`'s balance in a Minimal Swap Info Pool from cash into managed.\n     *\n     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that\n     * `token` is registered for that Pool.\n     */\n    function _minimalSwapInfoPoolCashToManaged(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal {\n        _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.cashToManaged, amount);\n    }\n\n    /**\n     * @dev Transforms `amount` of `token`'s balance in a Minimal Swap Info Pool from managed into cash.\n     *\n     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that\n     * `token` is registered for that Pool.\n     */\n    function _minimalSwapInfoPoolManagedToCash(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal {\n        _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.managedToCash, amount);\n    }\n\n    /**\n     * @dev Sets `token`'s managed balance in a Minimal Swap Info Pool to `amount`.\n     *\n     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that\n     * `token` is registered for that Pool.\n     *\n     * Returns the managed balance delta as a result of this call.\n     */\n    function _setMinimalSwapInfoPoolManagedBalance(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal returns (int256) {\n        return _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.setManaged, amount);\n    }\n\n    /**\n     * @dev Sets `token`'s balance in a Minimal Swap Info Pool to the result of the `mutation` function when called with\n     * the current balance and `amount`.\n     *\n     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that\n     * `token` is registered for that Pool.\n     *\n     * Returns the managed balance delta as a result of this call.\n     */\n    function _updateMinimalSwapInfoPoolBalance(\n        bytes32 poolId,\n        IERC20 token,\n        function(bytes32, uint256) returns (bytes32) mutation,\n        uint256 amount\n    ) internal returns (int256) {\n        bytes32 currentBalance = _getMinimalSwapInfoPoolBalance(poolId, token);\n\n        bytes32 newBalance = mutation(currentBalance, amount);\n        _minimalSwapInfoPoolsBalances[poolId][token] = newBalance;\n\n        return newBalance.managedDelta(currentBalance);\n    }\n\n    /**\n     * @dev Returns an array with all the tokens and balances in a Minimal Swap Info Pool. The order may change when\n     * tokens are registered or deregistered.\n     *\n     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.\n     */\n    function _getMinimalSwapInfoPoolTokens(bytes32 poolId)\n        internal\n        view\n        returns (IERC20[] memory tokens, bytes32[] memory balances)\n    {\n        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];\n        tokens = new IERC20[](poolTokens.length());\n        balances = new bytes32[](tokens.length);\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            // Because the iteration is bounded by `tokens.length`, which matches the EnumerableSet's length, we can use\n            // `unchecked_at` as we know `i` is a valid token index, saving storage reads.\n            IERC20 token = IERC20(poolTokens.unchecked_at(i));\n            tokens[i] = token;\n            balances[i] = _minimalSwapInfoPoolsBalances[poolId][token];\n        }\n    }\n\n    /**\n     * @dev Returns the balance of a token in a Minimal Swap Info Pool.\n     *\n     * Requirements:\n     *\n     * - `poolId` must be a Minimal Swap Info Pool\n     * - `token` must be registered in the Pool\n     */\n    function _getMinimalSwapInfoPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) {\n        bytes32 balance = _minimalSwapInfoPoolsBalances[poolId][token];\n\n        // A non-zero balance guarantees that the token is registered. If zero, we manually check if the token is\n        // registered in the Pool. Token registration implies that the Pool is registered as well, which lets us save\n        // gas by not performing the check.\n        bool tokenRegistered = balance.isNotZero() || _minimalSwapInfoPoolsTokens[poolId].contains(address(token));\n\n        if (!tokenRegistered) {\n            // The token might not be registered because the Pool itself is not registered. We check this to provide a\n            // more accurate revert reason.\n            _ensureRegisteredPool(poolId);\n            _revert(Errors.TOKEN_NOT_REGISTERED);\n        }\n\n        return balance;\n    }\n\n    /**\n     * @dev Returns true if `token` is registered in a Minimal Swap Info Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.\n     */\n    function _isMinimalSwapInfoPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) {\n        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];\n        return poolTokens.contains(address(token));\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/balances/TwoTokenPoolsBalance.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\n\nimport \"./BalanceAllocation.sol\";\nimport \"../PoolRegistry.sol\";\n\nabstract contract TwoTokenPoolsBalance is PoolRegistry {\n    using BalanceAllocation for bytes32;\n\n    // Data for Pools with the Two Token specialization setting\n    //\n    // These are similar to the Minimal Swap Info Pool case (because the Pool only has two tokens, and therefore there\n    // are only two balances to read), but there's a key difference in how data is stored. Keeping a set makes little\n    // sense, as it will only ever hold two tokens, so we can just store those two directly.\n    //\n    // The gas savings associated with using these Pools come from how token balances are stored: cash amounts for token\n    // A and token B are packed together, as are managed amounts. Because only cash changes in a swap, there's no need\n    // to write to this second storage slot. A single last change block number for both tokens is stored with the packed\n    // cash fields.\n\n    struct TwoTokenPoolBalances {\n        bytes32 sharedCash;\n        bytes32 sharedManaged;\n    }\n\n    // We could just keep a mapping from Pool ID to TwoTokenSharedBalances, but there's an issue: we wouldn't know to\n    // which tokens those balances correspond. This would mean having to also check which are registered with the Pool.\n    //\n    // What we do instead to save those storage reads is keep a nested mapping from the token pair hash to the balances\n    // struct. The Pool only has two tokens, so only a single entry of this mapping is set (the one that corresponds to\n    // that pair's hash).\n    //\n    // This has the trade-off of making Vault code that interacts with these Pools cumbersome: both balances must be\n    // accessed at the same time by using both token addresses, and some logic is needed to determine how the pair hash\n    // is computed. We do this by sorting the tokens, calling the token with the lowest numerical address value token A,\n    // and the other one token B. In functions where the token arguments could be either A or B, we use X and Y instead.\n    //\n    // If users query a token pair containing an unregistered token, the Pool will generate a hash for a mapping entry\n    // that was not set, and return zero balances. Non-zero balances are only possible if both tokens in the pair\n    // are registered with the Pool, which means we don't have to check the TwoTokenPoolTokens struct, and can save\n    // storage reads.\n\n    struct TwoTokenPoolTokens {\n        IERC20 tokenA;\n        IERC20 tokenB;\n        mapping(bytes32 => TwoTokenPoolBalances) balances;\n    }\n\n    mapping(bytes32 => TwoTokenPoolTokens) private _twoTokenPoolTokens;\n\n    /**\n     * @dev Registers tokens in a Two Token Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.\n     *\n     * Requirements:\n     *\n     * - `tokenX` and `tokenY` must not be the same\n     * - The tokens must be ordered: tokenX < tokenY\n     */\n    function _registerTwoTokenPoolTokens(\n        bytes32 poolId,\n        IERC20 tokenX,\n        IERC20 tokenY\n    ) internal {\n        // Not technically true since we didn't register yet, but this is consistent with the error messages of other\n        // specialization settings.\n        _require(tokenX != tokenY, Errors.TOKEN_ALREADY_REGISTERED);\n\n        _require(tokenX < tokenY, Errors.UNSORTED_TOKENS);\n\n        // A Two Token Pool with no registered tokens is identified by having zero addresses for tokens A and B.\n        TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId];\n        _require(poolTokens.tokenA == IERC20(0) && poolTokens.tokenB == IERC20(0), Errors.TOKENS_ALREADY_SET);\n\n        // Since tokenX < tokenY, tokenX is A and tokenY is B\n        poolTokens.tokenA = tokenX;\n        poolTokens.tokenB = tokenY;\n\n        // Note that we don't initialize the balance mapping: the default value of zero corresponds to an empty\n        // balance.\n    }\n\n    /**\n     * @dev Deregisters tokens in a Two Token Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.\n     *\n     * Requirements:\n     *\n     * - `tokenX` and `tokenY` must be registered in the Pool\n     * - both tokens must have zero balance in the Vault\n     */\n    function _deregisterTwoTokenPoolTokens(\n        bytes32 poolId,\n        IERC20 tokenX,\n        IERC20 tokenY\n    ) internal {\n        (\n            bytes32 balanceA,\n            bytes32 balanceB,\n            TwoTokenPoolBalances storage poolBalances\n        ) = _getTwoTokenPoolSharedBalances(poolId, tokenX, tokenY);\n\n        _require(balanceA.isZero() && balanceB.isZero(), Errors.NONZERO_TOKEN_BALANCE);\n\n        delete _twoTokenPoolTokens[poolId];\n\n        // For consistency with other Pool specialization settings, we explicitly reset the packed cash field (which may\n        // have a non-zero last change block).\n        delete poolBalances.sharedCash;\n    }\n\n    /**\n     * @dev Sets the cash balances of a Two Token Pool's tokens.\n     *\n     * WARNING: this assumes `tokenA` and `tokenB` are the Pool's two registered tokens, and are in the correct order.\n     */\n    function _setTwoTokenPoolCashBalances(\n        bytes32 poolId,\n        IERC20 tokenA,\n        bytes32 balanceA,\n        IERC20 tokenB,\n        bytes32 balanceB\n    ) internal {\n        bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB);\n        TwoTokenPoolBalances storage poolBalances = _twoTokenPoolTokens[poolId].balances[pairHash];\n        poolBalances.sharedCash = BalanceAllocation.toSharedCash(balanceA, balanceB);\n    }\n\n    /**\n     * @dev Transforms `amount` of `token`'s balance in a Two Token Pool from cash into managed.\n     *\n     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is\n     * registered for that Pool.\n     */\n    function _twoTokenPoolCashToManaged(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal {\n        _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.cashToManaged, amount);\n    }\n\n    /**\n     * @dev Transforms `amount` of `token`'s balance in a Two Token Pool from managed into cash.\n     *\n     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is\n     * registered for that Pool.\n     */\n    function _twoTokenPoolManagedToCash(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal {\n        _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.managedToCash, amount);\n    }\n\n    /**\n     * @dev Sets `token`'s managed balance in a Two Token Pool to `amount`.\n     *\n     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is\n     * registered for that Pool.\n     *\n     * Returns the managed balance delta as a result of this call.\n     */\n    function _setTwoTokenPoolManagedBalance(\n        bytes32 poolId,\n        IERC20 token,\n        uint256 amount\n    ) internal returns (int256) {\n        return _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.setManaged, amount);\n    }\n\n    /**\n     * @dev Sets `token`'s balance in a Two Token Pool to the result of the `mutation` function when called with\n     * the current balance and `amount`.\n     *\n     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is\n     * registered for that Pool.\n     *\n     * Returns the managed balance delta as a result of this call.\n     */\n    function _updateTwoTokenPoolSharedBalance(\n        bytes32 poolId,\n        IERC20 token,\n        function(bytes32, uint256) returns (bytes32) mutation,\n        uint256 amount\n    ) private returns (int256) {\n        (\n            TwoTokenPoolBalances storage balances,\n            IERC20 tokenA,\n            bytes32 balanceA,\n            ,\n            bytes32 balanceB\n        ) = _getTwoTokenPoolBalances(poolId);\n\n        int256 delta;\n        if (token == tokenA) {\n            bytes32 newBalance = mutation(balanceA, amount);\n            delta = newBalance.managedDelta(balanceA);\n            balanceA = newBalance;\n        } else {\n            // token == tokenB\n            bytes32 newBalance = mutation(balanceB, amount);\n            delta = newBalance.managedDelta(balanceB);\n            balanceB = newBalance;\n        }\n\n        balances.sharedCash = BalanceAllocation.toSharedCash(balanceA, balanceB);\n        balances.sharedManaged = BalanceAllocation.toSharedManaged(balanceA, balanceB);\n\n        return delta;\n    }\n\n    /*\n     * @dev Returns an array with all the tokens and balances in a Two Token Pool. The order may change when\n     * tokens are registered or deregistered.\n     *\n     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.\n     */\n    function _getTwoTokenPoolTokens(bytes32 poolId)\n        internal\n        view\n        returns (IERC20[] memory tokens, bytes32[] memory balances)\n    {\n        (, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB) = _getTwoTokenPoolBalances(poolId);\n\n        // Both tokens will either be zero (if unregistered) or non-zero (if registered), but we keep the full check for\n        // clarity.\n        if (tokenA == IERC20(0) || tokenB == IERC20(0)) {\n            return (new IERC20[](0), new bytes32[](0));\n        }\n\n        // Note that functions relying on this getter expect tokens to be properly ordered, so we use the (A, B)\n        // ordering.\n\n        tokens = new IERC20[](2);\n        tokens[0] = tokenA;\n        tokens[1] = tokenB;\n\n        balances = new bytes32[](2);\n        balances[0] = balanceA;\n        balances[1] = balanceB;\n    }\n\n    /**\n     * @dev Same as `_getTwoTokenPoolTokens`, except it returns the two tokens and balances directly instead of using\n     * an array, as well as a storage pointer to the `TwoTokenPoolBalances` struct, which can be used to update it\n     * without having to recompute the pair hash and storage slot.\n     */\n    function _getTwoTokenPoolBalances(bytes32 poolId)\n        private\n        view\n        returns (\n            TwoTokenPoolBalances storage poolBalances,\n            IERC20 tokenA,\n            bytes32 balanceA,\n            IERC20 tokenB,\n            bytes32 balanceB\n        )\n    {\n        TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId];\n        tokenA = poolTokens.tokenA;\n        tokenB = poolTokens.tokenB;\n\n        bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB);\n        poolBalances = poolTokens.balances[pairHash];\n\n        bytes32 sharedCash = poolBalances.sharedCash;\n        bytes32 sharedManaged = poolBalances.sharedManaged;\n\n        balanceA = BalanceAllocation.fromSharedToBalanceA(sharedCash, sharedManaged);\n        balanceB = BalanceAllocation.fromSharedToBalanceB(sharedCash, sharedManaged);\n    }\n\n    /**\n     * @dev Returns the balance of a token in a Two Token Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the General specialization setting.\n     *\n     * This function is convenient but not particularly gas efficient, and should be avoided during gas-sensitive\n     * operations, such as swaps. For those, _getTwoTokenPoolSharedBalances provides a more flexible interface.\n     *\n     * Requirements:\n     *\n     * - `token` must be registered in the Pool\n     */\n    function _getTwoTokenPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) {\n        // We can't just read the balance of token, because we need to know the full pair in order to compute the pair\n        // hash and access the balance mapping. We therefore rely on `_getTwoTokenPoolBalances`.\n        (, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB) = _getTwoTokenPoolBalances(poolId);\n\n        if (token == tokenA) {\n            return balanceA;\n        } else if (token == tokenB) {\n            return balanceB;\n        } else {\n            _revert(Errors.TOKEN_NOT_REGISTERED);\n        }\n    }\n\n    /**\n     * @dev Returns the balance of the two tokens in a Two Token Pool.\n     *\n     * The returned balances are those of token A and token B, where token A is the lowest of token X and token Y, and\n     * token B the other.\n     *\n     * This function also returns a storage pointer to the TwoTokenPoolBalances struct associated with the token pair,\n     * which can be used to update it without having to recompute the pair hash and storage slot.\n     *\n     * Requirements:\n     *\n     * - `poolId` must be a Minimal Swap Info Pool\n     * - `tokenX` and `tokenY` must be registered in the Pool\n     */\n    function _getTwoTokenPoolSharedBalances(\n        bytes32 poolId,\n        IERC20 tokenX,\n        IERC20 tokenY\n    )\n        internal\n        view\n        returns (\n            bytes32 balanceA,\n            bytes32 balanceB,\n            TwoTokenPoolBalances storage poolBalances\n        )\n    {\n        (IERC20 tokenA, IERC20 tokenB) = _sortTwoTokens(tokenX, tokenY);\n        bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB);\n\n        poolBalances = _twoTokenPoolTokens[poolId].balances[pairHash];\n\n        // Because we're reading balances using the pair hash, if either token X or token Y is not registered then\n        // *both* balance entries will be zero.\n        bytes32 sharedCash = poolBalances.sharedCash;\n        bytes32 sharedManaged = poolBalances.sharedManaged;\n\n        // A non-zero balance guarantees that both tokens are registered. If zero, we manually check whether each\n        // token is registered in the Pool. Token registration implies that the Pool is registered as well, which\n        // lets us save gas by not performing the check.\n        bool tokensRegistered = sharedCash.isNotZero() ||\n            sharedManaged.isNotZero() ||\n            (_isTwoTokenPoolTokenRegistered(poolId, tokenA) && _isTwoTokenPoolTokenRegistered(poolId, tokenB));\n\n        if (!tokensRegistered) {\n            // The tokens might not be registered because the Pool itself is not registered. We check this to provide a\n            // more accurate revert reason.\n            _ensureRegisteredPool(poolId);\n            _revert(Errors.TOKEN_NOT_REGISTERED);\n        }\n\n        balanceA = BalanceAllocation.fromSharedToBalanceA(sharedCash, sharedManaged);\n        balanceB = BalanceAllocation.fromSharedToBalanceB(sharedCash, sharedManaged);\n    }\n\n    /**\n     * @dev Returns true if `token` is registered in a Two Token Pool.\n     *\n     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.\n     */\n    function _isTwoTokenPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) {\n        TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId];\n\n        // The zero address can never be a registered token.\n        return (token == poolTokens.tokenA || token == poolTokens.tokenB) && token != IERC20(0);\n    }\n\n    /**\n     * @dev Returns the hash associated with a given token pair.\n     */\n    function _getTwoTokenPairHash(IERC20 tokenA, IERC20 tokenB) private pure returns (bytes32) {\n        return keccak256(abi.encodePacked(tokenA, tokenB));\n    }\n\n    /**\n     * @dev Sorts two tokens in ascending order, returning them as a (tokenA, tokenB) tuple.\n     */\n    function _sortTwoTokens(IERC20 tokenX, IERC20 tokenY) private pure returns (IERC20, IERC20) {\n        return tokenX < tokenY ? (tokenX, tokenY) : (tokenY, tokenX);\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableMap.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\n// Based on the EnumerableMap library from OpenZeppelin Contracts, altered to include the following:\n//  * a map from IERC20 to bytes32\n//  * entries are stored in mappings instead of arrays, reducing implicit storage reads for out-of-bounds checks\n//  * unchecked_at and unchecked_valueAt, which allow for more gas efficient data reads in some scenarios\n//  * unchecked_indexOf and unchecked_setAt, which allow for more gas efficient data writes in some scenarios\n//\n// Additionally, the base private functions that work on bytes32 were removed and replaced with a native implementation\n// for IERC20 keys, to reduce bytecode size and runtime costs.\n\npragma solidity ^0.7.0;\n\nimport \"./IERC20.sol\";\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Library for managing an enumerable variant of Solidity's\n * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]\n * type.\n *\n * Maps have the following properties:\n *\n * - Entries are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Entries are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n *     // Add the library methods\n *     using EnumerableMap for EnumerableMap.UintToAddressMap;\n *\n *     // Declare a set state variable\n *     EnumerableMap.UintToAddressMap private myMap;\n * }\n * ```\n */\nlibrary EnumerableMap {\n    // The original OpenZeppelin implementation uses a generic Map type with bytes32 keys: this was replaced with\n    // IERC20ToBytes32Map, which uses IERC20 keys natively, resulting in more dense bytecode.\n\n    struct IERC20ToBytes32MapEntry {\n        IERC20 _key;\n        bytes32 _value;\n    }\n\n    struct IERC20ToBytes32Map {\n        // Number of entries in the map\n        uint256 _length;\n        // Storage of map keys and values\n        mapping(uint256 => IERC20ToBytes32MapEntry) _entries;\n        // Position of the entry defined by a key in the `entries` array, plus 1\n        // because index 0 means a key is not in the map.\n        mapping(IERC20 => uint256) _indexes;\n    }\n\n    /**\n     * @dev Adds a key-value pair to a map, or updates the value for an existing\n     * key. O(1).\n     *\n     * Returns true if the key was added to the map, that is if it was not\n     * already present.\n     */\n    function set(\n        IERC20ToBytes32Map storage map,\n        IERC20 key,\n        bytes32 value\n    ) internal returns (bool) {\n        // We read and store the key's index to prevent multiple reads from the same storage slot\n        uint256 keyIndex = map._indexes[key];\n\n        // Equivalent to !contains(map, key)\n        if (keyIndex == 0) {\n            uint256 previousLength = map._length;\n            map._entries[previousLength] = IERC20ToBytes32MapEntry({ _key: key, _value: value });\n            map._length = previousLength + 1;\n\n            // The entry is stored at previousLength, but we add 1 to all indexes\n            // and use 0 as a sentinel value\n            map._indexes[key] = previousLength + 1;\n            return true;\n        } else {\n            map._entries[keyIndex - 1]._value = value;\n            return false;\n        }\n    }\n\n    /**\n     * @dev Updates the value for an entry, given its key's index. The key index can be retrieved via\n     * {unchecked_indexOf}, and it should be noted that key indices may change when calling {set} or {remove}. O(1).\n     *\n     * This function performs one less storage read than {set}, but it should only be used when `index` is known to be\n     * within bounds.\n     */\n    function unchecked_setAt(\n        IERC20ToBytes32Map storage map,\n        uint256 index,\n        bytes32 value\n    ) internal {\n        map._entries[index]._value = value;\n    }\n\n    /**\n     * @dev Removes a key-value pair from a map. O(1).\n     *\n     * Returns true if the key was removed from the map, that is if it was present.\n     */\n    function remove(IERC20ToBytes32Map storage map, IERC20 key) internal returns (bool) {\n        // We read and store the key's index to prevent multiple reads from the same storage slot\n        uint256 keyIndex = map._indexes[key];\n\n        // Equivalent to contains(map, key)\n        if (keyIndex != 0) {\n            // To delete a key-value pair from the _entries pseudo-array in O(1), we swap the entry to delete with the\n            // one at the highest index, and then remove this last entry (sometimes called as 'swap and pop').\n            // This modifies the order of the pseudo-array, as noted in {at}.\n\n            uint256 toDeleteIndex = keyIndex - 1;\n            uint256 lastIndex = map._length - 1;\n\n            // The swap is only necessary if we're not removing the last element\n            if (toDeleteIndex != lastIndex) {\n                IERC20ToBytes32MapEntry storage lastEntry = map._entries[lastIndex];\n\n                // Move the last entry to the index where the entry to delete is\n                map._entries[toDeleteIndex] = lastEntry;\n                // Update the index for the moved entry\n                map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based\n            }\n\n            // Delete the slot where the moved entry was stored\n            delete map._entries[lastIndex];\n            map._length = lastIndex;\n\n            // Delete the index for the deleted slot\n            delete map._indexes[key];\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Returns true if the key is in the map. O(1).\n     */\n    function contains(IERC20ToBytes32Map storage map, IERC20 key) internal view returns (bool) {\n        return map._indexes[key] != 0;\n    }\n\n    /**\n     * @dev Returns the number of key-value pairs in the map. O(1).\n     */\n    function length(IERC20ToBytes32Map storage map) internal view returns (uint256) {\n        return map._length;\n    }\n\n    /**\n     * @dev Returns the key-value pair stored at position `index` in the map. O(1).\n     *\n     * Note that there are no guarantees on the ordering of entries inside the\n     * array, and it may change when more entries are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(IERC20ToBytes32Map storage map, uint256 index) internal view returns (IERC20, bytes32) {\n        _require(map._length > index, Errors.OUT_OF_BOUNDS);\n        return unchecked_at(map, index);\n    }\n\n    /**\n     * @dev Same as {at}, except this doesn't revert if `index` it outside of the map (i.e. if it is equal or larger\n     * than {length}). O(1).\n     *\n     * This function performs one less storage read than {at}, but should only be used when `index` is known to be\n     * within bounds.\n     */\n    function unchecked_at(IERC20ToBytes32Map storage map, uint256 index) internal view returns (IERC20, bytes32) {\n        IERC20ToBytes32MapEntry storage entry = map._entries[index];\n        return (entry._key, entry._value);\n    }\n\n    /**\n     * @dev Same as {unchecked_At}, except it only returns the value and not the key (performing one less storage\n     * read). O(1).\n     */\n    function unchecked_valueAt(IERC20ToBytes32Map storage map, uint256 index) internal view returns (bytes32) {\n        return map._entries[index]._value;\n    }\n\n    /**\n     * @dev Returns the value associated with `key`. O(1).\n     *\n     * Requirements:\n     *\n     * - `key` must be in the map. Reverts with `errorCode` otherwise.\n     */\n    function get(\n        IERC20ToBytes32Map storage map,\n        IERC20 key,\n        uint256 errorCode\n    ) internal view returns (bytes32) {\n        uint256 index = map._indexes[key];\n        _require(index > 0, errorCode);\n        return unchecked_valueAt(map, index - 1);\n    }\n\n    /**\n     * @dev Returns the index for `key` **plus one**. Does not revert if the key is not in the map, and returns 0\n     * instead.\n     */\n    function unchecked_indexOf(IERC20ToBytes32Map storage map, IERC20 key) internal view returns (uint256) {\n        return map._indexes[key];\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\n// Based on the EnumerableSet library from OpenZeppelin Contracts, altered to remove the base private functions that\n// work on bytes32, replacing them with a native implementation for address values, to reduce bytecode size and runtime\n// costs.\n// The `unchecked_at` function was also added, which allows for more gas efficient data reads in some scenarios.\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n *     // Add the library methods\n *     using EnumerableSet for EnumerableSet.AddressSet;\n *\n *     // Declare a set state variable\n *     EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n    // The original OpenZeppelin implementation uses a generic Set type with bytes32 values: this was replaced with\n    // AddressSet, which uses address keys natively, resulting in more dense bytecode.\n\n    struct AddressSet {\n        // Storage of set values\n        address[] _values;\n        // Position of the value in the `values` array, plus 1 because index 0\n        // means a value is not in the set.\n        mapping(address => uint256) _indexes;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(AddressSet storage set, address value) internal returns (bool) {\n        if (!contains(set, value)) {\n            set._values.push(value);\n            // The value is stored at length-1, but we add 1 to all indexes\n            // and use 0 as a sentinel value\n            set._indexes[value] = set._values.length;\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(AddressSet storage set, address value) internal returns (bool) {\n        // We read and store the value's index to prevent multiple reads from the same storage slot\n        uint256 valueIndex = set._indexes[value];\n\n        if (valueIndex != 0) {\n            // Equivalent to contains(set, value)\n            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n            // the array, and then remove the last element (sometimes called as 'swap and pop').\n            // This modifies the order of the array, as noted in {at}.\n\n            uint256 toDeleteIndex = valueIndex - 1;\n            uint256 lastIndex = set._values.length - 1;\n\n            // The swap is only necessary if we're not removing the last element\n            if (toDeleteIndex != lastIndex) {\n                address lastValue = set._values[lastIndex];\n\n                // Move the last value to the index where the value to delete is\n                set._values[toDeleteIndex] = lastValue;\n                // Update the index for the moved value\n                set._indexes[lastValue] = toDeleteIndex + 1; // All indexes are 1-based\n            }\n\n            // Delete the slot where the moved value was stored\n            set._values.pop();\n\n            // Delete the index for the deleted slot\n            delete set._indexes[value];\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(AddressSet storage set, address value) internal view returns (bool) {\n        return set._indexes[value] != 0;\n    }\n\n    /**\n     * @dev Returns the number of values on the set. O(1).\n     */\n    function length(AddressSet storage set) internal view returns (uint256) {\n        return set._values.length;\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(AddressSet storage set, uint256 index) internal view returns (address) {\n        _require(set._values.length > index, Errors.OUT_OF_BOUNDS);\n        return unchecked_at(set, index);\n    }\n\n    /**\n     * @dev Same as {at}, except this doesn't revert if `index` it outside of the set (i.e. if it is equal or larger\n     * than {length}). O(1).\n     *\n     * This function performs one less storage read than {at}, but should only be used when `index` is known to be\n     * within bounds.\n     */\n    function unchecked_at(AddressSet storage set, uint256 index) internal view returns (address) {\n        return set._values[index];\n    }\n\n    function rawIndexOf(AddressSet storage set, address value) internal view returns (uint256) {\n        return set._indexes[value] - 1;\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/Swaps.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/math/Math.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableMap.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/EnumerableSet.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeCast.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\n\nimport \"./PoolBalances.sol\";\nimport \"./interfaces/IPoolSwapStructs.sol\";\nimport \"./interfaces/IGeneralPool.sol\";\nimport \"./interfaces/IMinimalSwapInfoPool.sol\";\nimport \"./balances/BalanceAllocation.sol\";\n\n/**\n * Implements the Vault's high-level swap functionality.\n *\n * Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. They need not trust the Pool\n * contracts to do this: all security checks are made by the Vault.\n *\n * The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence.\n * In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'),\n * and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out').\n * More complex swaps, such as one 'token in' to multiple tokens out can be achieved by batching together\n * individual swaps.\n */\nabstract contract Swaps is ReentrancyGuard, PoolBalances {\n    using SafeERC20 for IERC20;\n    using EnumerableSet for EnumerableSet.AddressSet;\n    using EnumerableMap for EnumerableMap.IERC20ToBytes32Map;\n\n    using Math for int256;\n    using Math for uint256;\n    using SafeCast for uint256;\n    using BalanceAllocation for bytes32;\n\n    function swap(\n        SingleSwap memory singleSwap,\n        FundManagement memory funds,\n        uint256 limit,\n        uint256 deadline\n    )\n        external\n        payable\n        override\n        nonReentrant\n        whenNotPaused\n        authenticateFor(funds.sender)\n        returns (uint256 amountCalculated)\n    {\n        // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy.\n        // solhint-disable-next-line not-rely-on-time\n        _require(block.timestamp <= deadline, Errors.SWAP_DEADLINE);\n\n        // This revert reason is for consistency with `batchSwap`: an equivalent `swap` performed using that function\n        // would result in this error.\n        _require(singleSwap.amount > 0, Errors.UNKNOWN_AMOUNT_IN_FIRST_SWAP);\n\n        IERC20 tokenIn = _translateToIERC20(singleSwap.assetIn);\n        IERC20 tokenOut = _translateToIERC20(singleSwap.assetOut);\n        _require(tokenIn != tokenOut, Errors.CANNOT_SWAP_SAME_TOKEN);\n\n        // Initializing each struct field one-by-one uses less gas than setting all at once.\n        IPoolSwapStructs.SwapRequest memory poolRequest;\n        poolRequest.poolId = singleSwap.poolId;\n        poolRequest.kind = singleSwap.kind;\n        poolRequest.tokenIn = tokenIn;\n        poolRequest.tokenOut = tokenOut;\n        poolRequest.amount = singleSwap.amount;\n        poolRequest.userData = singleSwap.userData;\n        poolRequest.from = funds.sender;\n        poolRequest.to = funds.recipient;\n        // The lastChangeBlock field is left uninitialized.\n\n        uint256 amountIn;\n        uint256 amountOut;\n\n        (amountCalculated, amountIn, amountOut) = _swapWithPool(poolRequest);\n        _require(singleSwap.kind == SwapKind.GIVEN_IN ? amountOut >= limit : amountIn <= limit, Errors.SWAP_LIMIT);\n\n        _receiveAsset(singleSwap.assetIn, amountIn, funds.sender, funds.fromInternalBalance);\n        _sendAsset(singleSwap.assetOut, amountOut, funds.recipient, funds.toInternalBalance);\n\n        // If the asset in is ETH, then `amountIn` ETH was wrapped into WETH.\n        _handleRemainingEth(_isETH(singleSwap.assetIn) ? amountIn : 0);\n    }\n\n    function batchSwap(\n        SwapKind kind,\n        BatchSwapStep[] memory swaps,\n        IAsset[] memory assets,\n        FundManagement memory funds,\n        int256[] memory limits,\n        uint256 deadline\n    )\n        external\n        payable\n        override\n        nonReentrant\n        whenNotPaused\n        authenticateFor(funds.sender)\n        returns (int256[] memory assetDeltas)\n    {\n        // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy.\n        // solhint-disable-next-line not-rely-on-time\n        _require(block.timestamp <= deadline, Errors.SWAP_DEADLINE);\n\n        InputHelpers.ensureInputLengthMatch(assets.length, limits.length);\n\n        // Perform the swaps, updating the Pool token balances and computing the net Vault asset deltas.\n        assetDeltas = _swapWithPools(swaps, assets, funds, kind);\n\n        // Process asset deltas, by either transferring assets from the sender (for positive deltas) or to the recipient\n        // (for negative deltas).\n        uint256 wrappedEth = 0;\n        for (uint256 i = 0; i < assets.length; ++i) {\n            IAsset asset = assets[i];\n            int256 delta = assetDeltas[i];\n            _require(delta <= limits[i], Errors.SWAP_LIMIT);\n\n            if (delta > 0) {\n                uint256 toReceive = uint256(delta);\n                _receiveAsset(asset, toReceive, funds.sender, funds.fromInternalBalance);\n\n                if (_isETH(asset)) {\n                    wrappedEth = wrappedEth.add(toReceive);\n                }\n            } else if (delta < 0) {\n                uint256 toSend = uint256(-delta);\n                _sendAsset(asset, toSend, funds.recipient, funds.toInternalBalance);\n            }\n        }\n\n        // Handle any used and remaining ETH.\n        _handleRemainingEth(wrappedEth);\n    }\n\n    // For `_swapWithPools` to handle both 'given in' and 'given out' swaps, it internally tracks the 'given' amount\n    // (supplied by the caller), and the 'calculated' amount (returned by the Pool in response to the swap request).\n\n    /**\n     * @dev Given the two swap tokens and the swap kind, returns which one is the 'given' token (the token whose\n     * amount is supplied by the caller).\n     */\n    function _tokenGiven(\n        SwapKind kind,\n        IERC20 tokenIn,\n        IERC20 tokenOut\n    ) private pure returns (IERC20) {\n        return kind == SwapKind.GIVEN_IN ? tokenIn : tokenOut;\n    }\n\n    /**\n     * @dev Given the two swap tokens and the swap kind, returns which one is the 'calculated' token (the token whose\n     * amount is calculated by the Pool).\n     */\n    function _tokenCalculated(\n        SwapKind kind,\n        IERC20 tokenIn,\n        IERC20 tokenOut\n    ) private pure returns (IERC20) {\n        return kind == SwapKind.GIVEN_IN ? tokenOut : tokenIn;\n    }\n\n    /**\n     * @dev Returns an ordered pair (amountIn, amountOut) given the 'given' and 'calculated' amounts, and the swap kind.\n     */\n    function _getAmounts(\n        SwapKind kind,\n        uint256 amountGiven,\n        uint256 amountCalculated\n    ) private pure returns (uint256 amountIn, uint256 amountOut) {\n        if (kind == SwapKind.GIVEN_IN) {\n            (amountIn, amountOut) = (amountGiven, amountCalculated);\n        } else {\n            // SwapKind.GIVEN_OUT\n            (amountIn, amountOut) = (amountCalculated, amountGiven);\n        }\n    }\n\n    /**\n     * @dev Performs all `swaps`, calling swap hooks on the Pool contracts and updating their balances. Does not cause\n     * any transfer of tokens - instead it returns the net Vault token deltas: positive if the Vault should receive\n     * tokens, and negative if it should send them.\n     */\n    function _swapWithPools(\n        BatchSwapStep[] memory swaps,\n        IAsset[] memory assets,\n        FundManagement memory funds,\n        SwapKind kind\n    ) private returns (int256[] memory assetDeltas) {\n        assetDeltas = new int256[](assets.length);\n\n        // These variables could be declared inside the loop, but that causes the compiler to allocate memory on each\n        // loop iteration, increasing gas costs.\n        BatchSwapStep memory batchSwapStep;\n        IPoolSwapStructs.SwapRequest memory poolRequest;\n\n        // These store data about the previous swap here to implement multihop logic across swaps.\n        IERC20 previousTokenCalculated;\n        uint256 previousAmountCalculated;\n\n        for (uint256 i = 0; i < swaps.length; ++i) {\n            batchSwapStep = swaps[i];\n\n            bool withinBounds = batchSwapStep.assetInIndex < assets.length &&\n                batchSwapStep.assetOutIndex < assets.length;\n            _require(withinBounds, Errors.OUT_OF_BOUNDS);\n\n            IERC20 tokenIn = _translateToIERC20(assets[batchSwapStep.assetInIndex]);\n            IERC20 tokenOut = _translateToIERC20(assets[batchSwapStep.assetOutIndex]);\n            _require(tokenIn != tokenOut, Errors.CANNOT_SWAP_SAME_TOKEN);\n\n            // Sentinel value for multihop logic\n            if (batchSwapStep.amount == 0) {\n                // When the amount given is zero, we use the calculated amount for the previous swap, as long as the\n                // current swap's given token is the previous calculated token. This makes it possible to swap a\n                // given amount of token A for token B, and then use the resulting token B amount to swap for token C.\n                _require(i > 0, Errors.UNKNOWN_AMOUNT_IN_FIRST_SWAP);\n                bool usingPreviousToken = previousTokenCalculated == _tokenGiven(kind, tokenIn, tokenOut);\n                _require(usingPreviousToken, Errors.MALCONSTRUCTED_MULTIHOP_SWAP);\n                batchSwapStep.amount = previousAmountCalculated;\n            }\n\n            // Initializing each struct field one-by-one uses less gas than setting all at once\n            poolRequest.poolId = batchSwapStep.poolId;\n            poolRequest.kind = kind;\n            poolRequest.tokenIn = tokenIn;\n            poolRequest.tokenOut = tokenOut;\n            poolRequest.amount = batchSwapStep.amount;\n            poolRequest.userData = batchSwapStep.userData;\n            poolRequest.from = funds.sender;\n            poolRequest.to = funds.recipient;\n            // The lastChangeBlock field is left uninitialized\n\n            uint256 amountIn;\n            uint256 amountOut;\n            (previousAmountCalculated, amountIn, amountOut) = _swapWithPool(poolRequest);\n\n            previousTokenCalculated = _tokenCalculated(kind, tokenIn, tokenOut);\n\n            // Accumulate Vault deltas across swaps\n            assetDeltas[batchSwapStep.assetInIndex] = assetDeltas[batchSwapStep.assetInIndex].add(amountIn.toInt256());\n            assetDeltas[batchSwapStep.assetOutIndex] = assetDeltas[batchSwapStep.assetOutIndex].sub(\n                amountOut.toInt256()\n            );\n        }\n    }\n\n    /**\n     * @dev Performs a swap according to the parameters specified in `request`, calling the Pool's contract hook and\n     * updating the Pool's balance.\n     *\n     * Returns the amount of tokens going into or out of the Vault as a result of this swap, depending on the swap kind.\n     */\n    function _swapWithPool(IPoolSwapStructs.SwapRequest memory request)\n        private\n        returns (\n            uint256 amountCalculated,\n            uint256 amountIn,\n            uint256 amountOut\n        )\n    {\n        // Get the calculated amount from the Pool and update its balances\n        address pool = _getPoolAddress(request.poolId);\n        PoolSpecialization specialization = _getPoolSpecialization(request.poolId);\n\n        if (specialization == PoolSpecialization.TWO_TOKEN) {\n            amountCalculated = _processTwoTokenPoolSwapRequest(request, IMinimalSwapInfoPool(pool));\n        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {\n            amountCalculated = _processMinimalSwapInfoPoolSwapRequest(request, IMinimalSwapInfoPool(pool));\n        } else {\n            // PoolSpecialization.GENERAL\n            amountCalculated = _processGeneralPoolSwapRequest(request, IGeneralPool(pool));\n        }\n\n        (amountIn, amountOut) = _getAmounts(request.kind, request.amount, amountCalculated);\n        emit Swap(request.poolId, request.tokenIn, request.tokenOut, amountIn, amountOut);\n    }\n\n    function _processTwoTokenPoolSwapRequest(IPoolSwapStructs.SwapRequest memory request, IMinimalSwapInfoPool pool)\n        private\n        returns (uint256 amountCalculated)\n    {\n        // For gas efficiency reasons, this function uses low-level knowledge of how Two Token Pool balances are\n        // stored internally, instead of using getters and setters for all operations.\n\n        (\n            bytes32 tokenABalance,\n            bytes32 tokenBBalance,\n            TwoTokenPoolBalances storage poolBalances\n        ) = _getTwoTokenPoolSharedBalances(request.poolId, request.tokenIn, request.tokenOut);\n\n        // We have the two Pool balances, but we don't know which one is 'token in' or 'token out'.\n        bytes32 tokenInBalance;\n        bytes32 tokenOutBalance;\n\n        // In Two Token Pools, token A has a smaller address than token B\n        if (request.tokenIn < request.tokenOut) {\n            // in is A, out is B\n            tokenInBalance = tokenABalance;\n            tokenOutBalance = tokenBBalance;\n        } else {\n            // in is B, out is A\n            tokenOutBalance = tokenABalance;\n            tokenInBalance = tokenBBalance;\n        }\n\n        // Perform the swap request and compute the new balances for 'token in' and 'token out' after the swap\n        (tokenInBalance, tokenOutBalance, amountCalculated) = _callMinimalSwapInfoPoolOnSwapHook(\n            request,\n            pool,\n            tokenInBalance,\n            tokenOutBalance\n        );\n\n        // We check the token ordering again to create the new shared cash packed struct\n        poolBalances.sharedCash = request.tokenIn < request.tokenOut\n            ? BalanceAllocation.toSharedCash(tokenInBalance, tokenOutBalance) // in is A, out is B\n            : BalanceAllocation.toSharedCash(tokenOutBalance, tokenInBalance); // in is B, out is A\n    }\n\n    function _processMinimalSwapInfoPoolSwapRequest(\n        IPoolSwapStructs.SwapRequest memory request,\n        IMinimalSwapInfoPool pool\n    ) private returns (uint256 amountCalculated) {\n        bytes32 tokenInBalance = _getMinimalSwapInfoPoolBalance(request.poolId, request.tokenIn);\n        bytes32 tokenOutBalance = _getMinimalSwapInfoPoolBalance(request.poolId, request.tokenOut);\n\n        // Perform the swap request and compute the new balances for 'token in' and 'token out' after the swap\n        (tokenInBalance, tokenOutBalance, amountCalculated) = _callMinimalSwapInfoPoolOnSwapHook(\n            request,\n            pool,\n            tokenInBalance,\n            tokenOutBalance\n        );\n\n        _minimalSwapInfoPoolsBalances[request.poolId][request.tokenIn] = tokenInBalance;\n        _minimalSwapInfoPoolsBalances[request.poolId][request.tokenOut] = tokenOutBalance;\n    }\n\n    /**\n     * @dev Calls the onSwap hook for a Pool that implements IMinimalSwapInfoPool: both Minimal Swap Info and Two Token\n     * Pools do this.\n     */\n    function _callMinimalSwapInfoPoolOnSwapHook(\n        IPoolSwapStructs.SwapRequest memory request,\n        IMinimalSwapInfoPool pool,\n        bytes32 tokenInBalance,\n        bytes32 tokenOutBalance\n    )\n        internal\n        returns (\n            bytes32 newTokenInBalance,\n            bytes32 newTokenOutBalance,\n            uint256 amountCalculated\n        )\n    {\n        uint256 tokenInTotal = tokenInBalance.total();\n        uint256 tokenOutTotal = tokenOutBalance.total();\n        request.lastChangeBlock = Math.max(tokenInBalance.lastChangeBlock(), tokenOutBalance.lastChangeBlock());\n\n        // Perform the swap request callback, and compute the new balances for 'token in' and 'token out' after the swap\n        amountCalculated = pool.onSwap(request, tokenInTotal, tokenOutTotal);\n        (uint256 amountIn, uint256 amountOut) = _getAmounts(request.kind, request.amount, amountCalculated);\n\n        newTokenInBalance = tokenInBalance.increaseCash(amountIn);\n        newTokenOutBalance = tokenOutBalance.decreaseCash(amountOut);\n    }\n\n    function _processGeneralPoolSwapRequest(IPoolSwapStructs.SwapRequest memory request, IGeneralPool pool)\n        private\n        returns (uint256 amountCalculated)\n    {\n        bytes32 tokenInBalance;\n        bytes32 tokenOutBalance;\n\n        // We access both token indexes without checking existence, because we will do it manually immediately after.\n        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[request.poolId];\n        uint256 indexIn = poolBalances.unchecked_indexOf(request.tokenIn);\n        uint256 indexOut = poolBalances.unchecked_indexOf(request.tokenOut);\n\n        if (indexIn == 0 || indexOut == 0) {\n            // The tokens might not be registered because the Pool itself is not registered. We check this to provide a\n            // more accurate revert reason.\n            _ensureRegisteredPool(request.poolId);\n            _revert(Errors.TOKEN_NOT_REGISTERED);\n        }\n\n        // EnumerableMap stores indices *plus one* to use the zero index as a sentinel value - because these are valid,\n        // we can undo this.\n        indexIn -= 1;\n        indexOut -= 1;\n\n        uint256 tokenAmount = poolBalances.length();\n        uint256[] memory currentBalances = new uint256[](tokenAmount);\n\n        request.lastChangeBlock = 0;\n        for (uint256 i = 0; i < tokenAmount; i++) {\n            // Because the iteration is bounded by `tokenAmount`, and no tokens are registered or deregistered here, we\n            // know `i` is a valid token index and can use `unchecked_valueAt` to save storage reads.\n            bytes32 balance = poolBalances.unchecked_valueAt(i);\n\n            currentBalances[i] = balance.total();\n            request.lastChangeBlock = Math.max(request.lastChangeBlock, balance.lastChangeBlock());\n\n            if (i == indexIn) {\n                tokenInBalance = balance;\n            } else if (i == indexOut) {\n                tokenOutBalance = balance;\n            }\n        }\n\n        // Perform the swap request callback and compute the new balances for 'token in' and 'token out' after the swap\n        amountCalculated = pool.onSwap(request, currentBalances, indexIn, indexOut);\n        (uint256 amountIn, uint256 amountOut) = _getAmounts(request.kind, request.amount, amountCalculated);\n        tokenInBalance = tokenInBalance.increaseCash(amountIn);\n        tokenOutBalance = tokenOutBalance.decreaseCash(amountOut);\n\n        // Because no tokens were registered or deregistered between now or when we retrieved the indexes for\n        // 'token in' and 'token out', we can use `unchecked_setAt` to save storage reads.\n        poolBalances.unchecked_setAt(indexIn, tokenInBalance);\n        poolBalances.unchecked_setAt(indexOut, tokenOutBalance);\n    }\n\n    // This function is not marked as `nonReentrant` because the underlying mechanism relies on reentrancy\n    function queryBatchSwap(\n        SwapKind kind,\n        BatchSwapStep[] memory swaps,\n        IAsset[] memory assets,\n        FundManagement memory funds\n    ) external override returns (int256[] memory) {\n        // In order to accurately 'simulate' swaps, this function actually does perform the swaps, including calling the\n        // Pool hooks and updating balances in storage. However, once it computes the final Vault Deltas, it\n        // reverts unconditionally, returning this array as the revert data.\n        //\n        // By wrapping this reverting call, we can decode the deltas 'returned' and return them as a normal Solidity\n        // function would. The only caveat is the function becomes non-view, but off-chain clients can still call it\n        // via eth_call to get the expected result.\n        //\n        // This technique was inspired by the work from the Gnosis team in the Gnosis Safe contract:\n        // https://github.com/gnosis/safe-contracts/blob/v1.2.0/contracts/GnosisSafe.sol#L265\n        //\n        // Most of this function is implemented using inline assembly, as the actual work it needs to do is not\n        // significant, and Solidity is not particularly well-suited to generate this behavior, resulting in a large\n        // amount of generated bytecode.\n\n        if (msg.sender != address(this)) {\n            // We perform an external call to ourselves, forwarding the same calldata. In this call, the else clause of\n            // the preceding if statement will be executed instead.\n\n            // solhint-disable-next-line avoid-low-level-calls\n            (bool success, ) = address(this).call(msg.data);\n\n            // solhint-disable-next-line no-inline-assembly\n            assembly {\n                // This call should always revert to decode the actual asset deltas from the revert reason\n                switch success\n                    case 0 {\n                        // Note we are manually writing the memory slot 0. We can safely overwrite whatever is\n                        // stored there as we take full control of the execution and then immediately return.\n\n                        // We copy the first 4 bytes to check if it matches with the expected signature, otherwise\n                        // there was another revert reason and we should forward it.\n                        returndatacopy(0, 0, 0x04)\n                        let error := and(mload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)\n\n                        // If the first 4 bytes don't match with the expected signature, we forward the revert reason.\n                        if eq(eq(error, 0xfa61cc1200000000000000000000000000000000000000000000000000000000), 0) {\n                            returndatacopy(0, 0, returndatasize())\n                            revert(0, returndatasize())\n                        }\n\n                        // The returndata contains the signature, followed by the raw memory representation of an array:\n                        // length + data. We need to return an ABI-encoded representation of this array.\n                        // An ABI-encoded array contains an additional field when compared to its raw memory\n                        // representation: an offset to the location of the length. The offset itself is 32 bytes long,\n                        // so the smallest value we  can use is 32 for the data to be located immediately after it.\n                        mstore(0, 32)\n\n                        // We now copy the raw memory array from returndata into memory. Since the offset takes up 32\n                        // bytes, we start copying at address 0x20. We also get rid of the error signature, which takes\n                        // the first four bytes of returndata.\n                        let size := sub(returndatasize(), 0x04)\n                        returndatacopy(0x20, 0x04, size)\n\n                        // We finally return the ABI-encoded array, which has a total length equal to that of the array\n                        // (returndata), plus the 32 bytes for the offset.\n                        return(0, add(size, 32))\n                    }\n                    default {\n                        // This call should always revert, but we fail nonetheless if that didn't happen\n                        invalid()\n                    }\n            }\n        } else {\n            int256[] memory deltas = _swapWithPools(swaps, assets, funds, kind);\n\n            // solhint-disable-next-line no-inline-assembly\n            assembly {\n                // We will return a raw representation of the array in memory, which is composed of a 32 byte length,\n                // followed by the 32 byte int256 values. Because revert expects a size in bytes, we multiply the array\n                // length (stored at `deltas`) by 32.\n                let size := mul(mload(deltas), 32)\n\n                // We send one extra value for the error signature \"QueryError(int256[])\" which is 0xfa61cc12.\n                // We store it in the previous slot to the `deltas` array. We know there will be at least one available\n                // slot due to how the memory scratch space works.\n                // We can safely overwrite whatever is stored in this slot as we will revert immediately after that.\n                mstore(sub(deltas, 0x20), 0x00000000000000000000000000000000000000000000000000000000fa61cc12)\n                let start := sub(deltas, 0x04)\n\n                // When copying from `deltas` into returndata, we copy an additional 36 bytes to also return the array's\n                // length and the error signature.\n                revert(start, add(size, 36))\n            }\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/interfaces/IGeneralPool.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"./IBasePool.sol\";\n\n/**\n * @dev IPools with the General specialization setting should implement this interface.\n *\n * This is called by the Vault when a user calls `IVault.swap` or `IVault.batchSwap` to swap with this Pool.\n * Returns the number of tokens the Pool will grant to the user in a 'given in' swap, or that the user will\n * grant to the pool in a 'given out' swap.\n *\n * This can often be implemented by a `view` function, since many pricing algorithms don't need to track state\n * changes in swaps. However, contracts implementing this in non-view functions should check that the caller is\n * indeed the Vault.\n */\ninterface IGeneralPool is IBasePool {\n    function onSwap(\n        SwapRequest memory swapRequest,\n        uint256[] memory balances,\n        uint256 indexIn,\n        uint256 indexOut\n    ) external returns (uint256 amount);\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/FlashLoans.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n// This flash loan provider was based on the Aave protocol's open source\n// implementation and terminology and interfaces are intentionally kept\n// similar\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/BalancerErrors.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/IERC20.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/ReentrancyGuard.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/SafeERC20.sol\";\n\nimport \"./Fees.sol\";\nimport \"./interfaces/IFlashLoanRecipient.sol\";\n\n/**\n * @dev Handles Flash Loans through the Vault. Calls the `receiveFlashLoan` hook on the flash loan recipient\n * contract, which implements the `IFlashLoanRecipient` interface.\n */\nabstract contract FlashLoans is Fees, ReentrancyGuard, TemporarilyPausable {\n    using SafeERC20 for IERC20;\n\n    function flashLoan(\n        IFlashLoanRecipient recipient,\n        IERC20[] memory tokens,\n        uint256[] memory amounts,\n        bytes memory userData\n    ) external override nonReentrant whenNotPaused {\n        InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length);\n\n        uint256[] memory feeAmounts = new uint256[](tokens.length);\n        uint256[] memory preLoanBalances = new uint256[](tokens.length);\n\n        // Used to ensure `tokens` is sorted in ascending order, which ensures token uniqueness.\n        IERC20 previousToken = IERC20(0);\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            IERC20 token = tokens[i];\n            uint256 amount = amounts[i];\n\n            _require(token > previousToken, token == IERC20(0) ? Errors.ZERO_TOKEN : Errors.UNSORTED_TOKENS);\n            previousToken = token;\n\n            preLoanBalances[i] = token.balanceOf(address(this));\n            feeAmounts[i] = _calculateFlashLoanFeeAmount(amount);\n\n            _require(preLoanBalances[i] >= amount, Errors.INSUFFICIENT_FLASH_LOAN_BALANCE);\n            token.safeTransfer(address(recipient), amount);\n        }\n\n        recipient.receiveFlashLoan(tokens, amounts, feeAmounts, userData);\n\n        for (uint256 i = 0; i < tokens.length; ++i) {\n            IERC20 token = tokens[i];\n            uint256 preLoanBalance = preLoanBalances[i];\n\n            // Checking for loan repayment first (without accounting for fees) makes for simpler debugging, and results\n            // in more accurate revert reasons if the flash loan protocol fee percentage is zero.\n            uint256 postLoanBalance = token.balanceOf(address(this));\n            _require(postLoanBalance >= preLoanBalance, Errors.INVALID_POST_LOAN_BALANCE);\n\n            // No need for checked arithmetic since we know the loan was fully repaid.\n            uint256 receivedFeeAmount = postLoanBalance - preLoanBalance;\n            _require(receivedFeeAmount >= feeAmounts[i], Errors.INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT);\n\n            _payFeeAmount(token, receivedFeeAmount);\n            emit FlashLoan(recipient, token, amounts[i], receivedFeeAmount);\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/Vault.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport \"@balancer-labs/v2-solidity-utils/contracts/misc/IWETH.sol\";\n\nimport \"./interfaces/IAuthorizer.sol\";\n\nimport \"./VaultAuthorization.sol\";\nimport \"./FlashLoans.sol\";\nimport \"./Swaps.sol\";\n\n/**\n * @dev The `Vault` is Balancer V2's core contract. A single instance of it exists for the entire network, and it is the\n * entity used to interact with Pools by Liquidity Providers who join and exit them, Traders who swap, and Asset\n * Managers who withdraw and deposit tokens.\n *\n * The `Vault`'s source code is split among a number of sub-contracts, with the goal of improving readability and making\n * understanding the system easier. Most sub-contracts have been marked as `abstract` to explicitly indicate that only\n * the full `Vault` is meant to be deployed.\n *\n * Roughly speaking, these are the contents of each sub-contract:\n *\n *  - `AssetManagers`: Pool token Asset Manager registry, and Asset Manager interactions.\n *  - `Fees`: set and compute protocol fees.\n *  - `FlashLoans`: flash loan transfers and fees.\n *  - `PoolBalances`: Pool joins and exits.\n *  - `PoolRegistry`: Pool registration, ID management, and basic queries.\n *  - `PoolTokens`: Pool token registration and registration, and balance queries.\n *  - `Swaps`: Pool swaps.\n *  - `UserBalance`: manage user balances (Internal Balance operations and external balance transfers)\n *  - `VaultAuthorization`: access control, relayers and signature validation.\n *\n * Additionally, the different Pool specializations are handled by the `GeneralPoolsBalance`,\n * `MinimalSwapInfoPoolsBalance` and `TwoTokenPoolsBalance` sub-contracts, which in turn make use of the\n * `BalanceAllocation` library.\n *\n * The most important goal of the `Vault` is to make token swaps use as little gas as possible. This is reflected in a\n * multitude of design decisions, from minor things like the format used to store Pool IDs, to major features such as\n * the different Pool specialization settings.\n *\n * Finally, the large number of tasks carried out by the Vault means its bytecode is very large, close to exceeding\n * the contract size limit imposed by EIP 170 (https://eips.ethereum.org/EIPS/eip-170). Manual tuning of the source code\n * was required to improve code generation and bring the bytecode size below this limit. This includes extensive\n * utilization of `internal` functions (particularly inside modifiers), usage of named return arguments, dedicated\n * storage access methods, dynamic revert reason generation, and usage of inline assembly, to name a few.\n */\ncontract Vault is VaultAuthorization, FlashLoans, Swaps {\n    constructor(\n        IAuthorizer authorizer,\n        IWETH weth,\n        uint256 pauseWindowDuration,\n        uint256 bufferPeriodDuration\n    ) VaultAuthorization(authorizer) AssetHelpers(weth) TemporarilyPausable(pauseWindowDuration, bufferPeriodDuration) {\n        // solhint-disable-previous-line no-empty-blocks\n    }\n\n    function setPaused(bool paused) external override nonReentrant authenticate {\n        _setPaused(paused);\n    }\n\n    // solhint-disable-next-line func-name-mixedcase\n    function WETH() external view override returns (IWETH) {\n        return _WETH();\n    }\n}\n"
    },
    "@balancer-labs/v2-vault/contracts/Authorizer.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\n// This program is free software: you can redistribute it and/or modify\n// it under the terms of the GNU General Public License as published by\n// the Free Software Foundation, either version 3 of the License, or\n// (at your option) any later version.\n\n// This program is distributed in the hope that it will be useful,\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n// GNU General Public License for more details.\n\n// You should have received a copy of the GNU General Public License\n// along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\npragma solidity ^0.7.0;\n\nimport \"./interfaces/IAuthorizer.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/openzeppelin/AccessControl.sol\";\nimport \"@balancer-labs/v2-solidity-utils/contracts/helpers/InputHelpers.sol\";\n\n/**\n * @dev Basic Authorizer implementation, based on OpenZeppelin's Access Control.\n *\n * Users are allowed to perform actions if they have the role with the same identifier. In this sense, roles are not\n * being truly used as such, since they each map to a single action identifier.\n *\n * This temporary implementation is expected to be replaced soon after launch by a more sophisticated one, able to\n * manage permissions across multiple contracts and to natively handle timelocks.\n */\ncontract Authorizer is AccessControl, IAuthorizer {\n    constructor(address admin) {\n        _setupRole(DEFAULT_ADMIN_ROLE, admin);\n    }\n\n    function canPerform(\n        bytes32 actionId,\n        address account,\n        address\n    ) public view override returns (bool) {\n        // This Authorizer ignores the 'where' field completely.\n        return AccessControl.hasRole(actionId, account);\n    }\n\n    /**\n     * @dev Grants multiple roles to a single account.\n     */\n    function grantRoles(bytes32[] memory roles, address account) external {\n        for (uint256 i = 0; i < roles.length; i++) {\n            grantRole(roles[i], account);\n        }\n    }\n\n    /**\n     * @dev Grants roles to a list of accounts.\n     */\n    function grantRolesToMany(bytes32[] memory roles, address[] memory accounts) external {\n        InputHelpers.ensureInputLengthMatch(roles.length, accounts.length);\n        for (uint256 i = 0; i < roles.length; i++) {\n            grantRole(roles[i], accounts[i]);\n        }\n    }\n\n    /**\n     * @dev Revokes multiple roles from a single account.\n     */\n    function revokeRoles(bytes32[] memory roles, address account) external {\n        for (uint256 i = 0; i < roles.length; i++) {\n            revokeRole(roles[i], account);\n        }\n    }\n\n    /**\n     * @dev Revokes roles from a list of accounts.\n     */\n    function revokeRolesFromMany(bytes32[] memory roles, address[] memory accounts) external {\n        InputHelpers.ensureInputLengthMatch(roles.length, accounts.length);\n        for (uint256 i = 0; i < roles.length; i++) {\n            revokeRole(roles[i], accounts[i]);\n        }\n    }\n}\n"
    },
    "@balancer-labs/v2-solidity-utils/contracts/openzeppelin/AccessControl.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.7.0;\n\nimport \"../helpers/BalancerErrors.sol\";\n\nimport \"./EnumerableSet.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it.\n */\nabstract contract AccessControl {\n    using EnumerableSet for EnumerableSet.AddressSet;\n\n    struct RoleData {\n        EnumerableSet.AddressSet members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual returns (bool) {\n        return _roles[role].members.contains(account);\n    }\n\n    /**\n     * @dev Returns the number of accounts that have `role`. Can be used\n     * together with {getRoleMember} to enumerate all bearers of a role.\n     */\n    function getRoleMemberCount(bytes32 role) public view returns (uint256) {\n        return _roles[role].members.length();\n    }\n\n    /**\n     * @dev Returns one of the accounts that have `role`. `index` must be a\n     * value between 0 and {getRoleMemberCount}, non-inclusive.\n     *\n     * Role bearers are not sorted in any particular way, and their ordering may\n     * change at any point.\n     *\n     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure\n     * you perform all queries on the same block. See the following\n     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]\n     * for more information.\n     */\n    function getRoleMember(bytes32 role, uint256 index) public view returns (address) {\n        return _roles[role].members.at(index);\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) public virtual {\n        _require(hasRole(_roles[role].adminRole, msg.sender), Errors.GRANT_SENDER_NOT_ADMIN);\n\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had already been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) public virtual {\n        _require(hasRole(_roles[role].adminRole, msg.sender), Errors.REVOKE_SENDER_NOT_ADMIN);\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) public virtual {\n        _require(account == msg.sender, Errors.RENOUNCE_SENDER_NOT_ALLOWED);\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);\n        _roles[role].adminRole = adminRole;\n    }\n\n    function _grantRole(bytes32 role, address account) private {\n        if (_roles[role].members.add(account)) {\n            emit RoleGranted(role, account, msg.sender);\n        }\n    }\n\n    function _revokeRole(bytes32 role, address account) private {\n        if (_roles[role].members.remove(account)) {\n            emit RoleRevoked(role, account, msg.sender);\n        }\n    }\n}\n"
    },
    "src/space.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.7.0;\npragma experimental ABIEncoderV2;\n\nimport { Authorizer } from \"@balancer-labs/v2-vault/contracts/Authorizer.sol\";\nimport { Vault } from \"@balancer-labs/v2-vault/contracts/Vault.sol\";\nimport { Space } from \"../lib/v1-space/src/Space.sol\";\nimport { SpaceFactory } from \"../lib/v1-space/src/SpaceFactory.sol\";"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 500
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "metadata": {
      "useLiteralContent": true
    },
    "libraries": {
      "lib/v1-space/src/oracle/QueryProcessor.sol": {
        "QueryProcessor": "0xcbe8c43a6e3be093489b5b1bff2e851d01d451f6"
      }
    }
  }
}