Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

pragma solidity 0.8.19;

/**
 * @dev This is an empty interface used to represent either ERC20-conforming token contracts or ETH (using the zero
 * address sentinel value). We're just relying on the fact that `interface` can be used to declare new address-like
 * types.
 *
 * This concept is unrelated to a Pool's Asset Managers.
 */
interface IAsset {
    // solhint-disable-previous-line no-empty-blocks
}

pragma solidity 0.8.19;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _HASHED_NAME = keccak256(bytes(name));
        _HASHED_VERSION = keccak256(bytes(version));
        _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view virtual returns (bytes32) {
        return keccak256(abi.encode(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION, _getChainId(), address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(), structHash));
    }

    function _getChainId() private view returns (uint256 chainId) {
        // Silence state mutability warning without generating bytecode.
        // See https://github.com/ethereum/solidity/issues/10090#issuecomment-741789128 and
        // https://github.com/ethereum/solidity/issues/2691
        this;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            chainId := chainid()
        }
    }
}

pragma solidity 0.8.19;

/**
 * @dev Interface for the SignatureValidator helper, used to support meta-transactions.
 */
interface ISignaturesValidator {
    /**
     * @dev Returns the EIP712 domain separator.
     */
    function getDomainSeparator() external view returns (bytes32);

    /**
     * @dev Returns the next nonce used by an address to sign messages.
     */
    function getNextNonce(address user) external view returns (uint256);
}

pragma solidity 0.8.19;

/**
 * @dev Interface for the TemporarilyPausable helper.
 */
interface ITemporarilyPausable {
    /**
     * @dev Emitted every time the pause state changes by `_setPaused`.
     */
    event PausedStateChanged(bool paused);

    /**
     * @dev Returns the current paused state.
     */
    function getPausedState()
        external
        view
        returns (
            bool paused,
            uint256 pauseWindowEndTime,
            uint256 bufferPeriodEndTime
        );
}

pragma solidity 0.8.19;

interface IAuthentication {
    /**
     * @dev Returns the action identifier associated with the external function described by `selector`.
     */
    function getActionId(bytes4 selector) external view returns (bytes32);
}

pragma solidity 0.8.19;

// solhint-disable

/**
 * @dev Reverts if `condition` is false, with a revert reason containing `errorCode`. Only codes up to 999 are
 * supported.
 */
function _require(bool condition, uint256 errorCode) pure {
    if (!condition) _revert(errorCode);
}

/**
 * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported.
 */
function _revert(uint256 errorCode) pure {
    // We're going to dynamically create a revert string based on the error code, with the following format:
    // 'BAL#{errorCode}'
    // where the code is left-padded with zeroes to three digits (so they range from 000 to 999).
    //
    // We don't have revert strings embedded in the contract to save bytecode size: it takes much less space to store a
    // number (8 to 16 bits) than the individual string characters.
    //
    // The dynamic string creation algorithm that follows could be implemented in Solidity, but assembly allows for a
    // much denser implementation, again saving bytecode size. Given this function unconditionally reverts, this is a
    // safe place to rely on it without worrying about how its usage might affect e.g. memory contents.
    assembly {
        // First, we need to compute the ASCII representation of the error code. We assume that it is in the 0-999
        // range, so we only need to convert three digits. To convert the digits to ASCII, we add 0x30, the value for
        // the '0' character.

        let units := add(mod(errorCode, 10), 0x30)

        errorCode := div(errorCode, 10)
        let tenths := add(mod(errorCode, 10), 0x30)

        errorCode := div(errorCode, 10)
        let hundreds := add(mod(errorCode, 10), 0x30)

        // With the individual characters, we can now construct the full string. The "BAL#" part is a known constant
        // (0x42414c23): we simply shift this by 24 (to provide space for the 3 bytes of the error code), and add the
        // characters to it, each shifted by a multiple of 8.
        // The revert reason is then shifted left by 200 bits (256 minus the length of the string, 7 characters * 8 bits
        // per character = 56) to locate it in the most significant part of the 256 slot (the beginning of a byte
        // array).

        let revertReason := shl(200, add(0x42414c23000000, add(add(units, shl(8, tenths)), shl(16, hundreds))))

        // We can now encode the reason in memory, which can be safely overwritten as we're about to revert. The encoded
        // message will have the following layout:
        // [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ]

        // The Solidity revert reason identifier is 0x08c739a0, the function selector of the Error(string) function. We
        // also write zeroes to the next 28 bytes of memory, but those are about to be overwritten.
        mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000)
        // Next is the offset to the location of the string, which will be placed immediately after (20 bytes away).
        mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
        // The string length is fixed: 7 characters.
        mstore(0x24, 7)
        // Finally, the string itself is stored.
        mstore(0x44, revertReason)

        // Even if the string is only 7 bytes long, we need to return a full 32 byte slot containing it. The length of
        // the encoded message is therefore 4 + 32 + 32 + 32 = 100.
        revert(0, 100)
    }
}

library Errors {
    // Math
    uint256 internal constant ADD_OVERFLOW = 0;
    uint256 internal constant SUB_OVERFLOW = 1;
    uint256 internal constant SUB_UNDERFLOW = 2;
    uint256 internal constant MUL_OVERFLOW = 3;
    uint256 internal constant ZERO_DIVISION = 4;
    uint256 internal constant DIV_INTERNAL = 5;
    uint256 internal constant X_OUT_OF_BOUNDS = 6;
    uint256 internal constant Y_OUT_OF_BOUNDS = 7;
    uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8;
    uint256 internal constant INVALID_EXPONENT = 9;

    // Input
    uint256 internal constant OUT_OF_BOUNDS = 100;
    uint256 internal constant UNSORTED_ARRAY = 101;
    uint256 internal constant UNSORTED_TOKENS = 102;
    uint256 internal constant INPUT_LENGTH_MISMATCH = 103;
    uint256 internal constant ZERO_TOKEN = 104;

    // Shared pools
    uint256 internal constant MIN_TOKENS = 200;
    uint256 internal constant MAX_TOKENS = 201;
    uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202;
    uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203;
    uint256 internal constant MINIMUM_BPT = 204;
    uint256 internal constant CALLER_NOT_VAULT = 205;
    uint256 internal constant UNINITIALIZED = 206;
    uint256 internal constant BPT_IN_MAX_AMOUNT = 207;
    uint256 internal constant BPT_OUT_MIN_AMOUNT = 208;
    uint256 internal constant EXPIRED_PERMIT = 209;

    // Pools
    uint256 internal constant MIN_AMP = 300;
    uint256 internal constant MAX_AMP = 301;
    uint256 internal constant MIN_WEIGHT = 302;
    uint256 internal constant MAX_STABLE_TOKENS = 303;
    uint256 internal constant MAX_IN_RATIO = 304;
    uint256 internal constant MAX_OUT_RATIO = 305;
    uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306;
    uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307;
    uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308;
    uint256 internal constant INVALID_TOKEN = 309;
    uint256 internal constant UNHANDLED_JOIN_KIND = 310;
    uint256 internal constant ZERO_INVARIANT = 311;

    // Lib
    uint256 internal constant REENTRANCY = 400;
    uint256 internal constant SENDER_NOT_ALLOWED = 401;
    uint256 internal constant PAUSED = 402;
    uint256 internal constant PAUSE_WINDOW_EXPIRED = 403;
    uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404;
    uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405;
    uint256 internal constant INSUFFICIENT_BALANCE = 406;
    uint256 internal constant INSUFFICIENT_ALLOWANCE = 407;
    uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408;
    uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409;
    uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410;
    uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411;
    uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412;
    uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413;
    uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414;
    uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415;
    uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416;
    uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417;
    uint256 internal constant SAFE_ERC20_CALL_FAILED = 418;
    uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419;
    uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420;
    uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421;
    uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422;
    uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423;
    uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424;
    uint256 internal constant BUFFER_PERIOD_EXPIRED = 425;

    // Vault
    uint256 internal constant INVALID_POOL_ID = 500;
    uint256 internal constant CALLER_NOT_POOL = 501;
    uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502;
    uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503;
    uint256 internal constant INVALID_SIGNATURE = 504;
    uint256 internal constant EXIT_BELOW_MIN = 505;
    uint256 internal constant JOIN_ABOVE_MAX = 506;
    uint256 internal constant SWAP_LIMIT = 507;
    uint256 internal constant SWAP_DEADLINE = 508;
    uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509;
    uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510;
    uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511;
    uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512;
    uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513;
    uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514;
    uint256 internal constant INVALID_POST_LOAN_BALANCE = 515;
    uint256 internal constant INSUFFICIENT_ETH = 516;
    uint256 internal constant UNALLOCATED_ETH = 517;
    uint256 internal constant ETH_TRANSFER = 518;
    uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519;
    uint256 internal constant TOKENS_MISMATCH = 520;
    uint256 internal constant TOKEN_NOT_REGISTERED = 521;
    uint256 internal constant TOKEN_ALREADY_REGISTERED = 522;
    uint256 internal constant TOKENS_ALREADY_SET = 523;
    uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524;
    uint256 internal constant NONZERO_TOKEN_BALANCE = 525;
    uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526;
    uint256 internal constant POOL_NO_TOKENS = 527;
    uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528;

    // Fees
    uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600;
    uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601;
    uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602;
}

pragma solidity 0.8.19;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        _require(address(this).balance >= amount, Errors.ADDRESS_INSUFFICIENT_BALANCE);

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        _require(success, Errors.ADDRESS_CANNOT_SEND_VALUE);
    }
}

pragma solidity 0.8.19;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        _require(value < 2**255, Errors.SAFE_CAST_VALUE_CANT_FIT_INT256);
        return int256(value);
    }
}

pragma solidity 0.8.19;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // The original OpenZeppelin implementation uses a generic Set type with bytes32 values: this was replaced with
    // AddressSet, which uses address keys natively, resulting in more dense bytecode.

    struct AddressSet {
        // Storage of set values
        address[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(address => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        if (!contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            address lastValue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastValue;
            // Update the index for the moved value
            set._indexes[lastValue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        _require(set._values.length > index, Errors.OUT_OF_BOUNDS);
        return unchecked_at(set, index);
    }

    /**
     * @dev Same as {at}, except this doesn't revert if `index` it outside of the set (i.e. if it is equal or larger
     * than {length}). O(1).
     *
     * This function performs one less storage read than {at}, but should only be used when `index` is known to be
     * within bounds.
     */
    function unchecked_at(AddressSet storage set, uint256 index) internal view returns (address) {
        return set._values[index];
    }
}

pragma solidity 0.8.19;

/* solhint-disable */

/**
 * @dev Exponentiation and logarithm functions for 18 decimal fixed point numbers (both base and exponent/argument).
 *
 * Exponentiation and logarithm with arbitrary bases (x^y and log_x(y)) are implemented by conversion to natural
 * exponentiation and logarithm (where the base is Euler's number).
 *
 * @author Fernando Martinelli - @fernandomartinelli
 * @author Sergio Yuhjtman - @sergioyuhjtman
 * @author Daniel Fernandez - @dmf7z
 */
library LogExpMath {
    // All fixed point multiplications and divisions are inlined. This means we need to divide by ONE when multiplying
    // two numbers, and multiply by ONE when dividing them.

    // All arguments and return values are 18 decimal fixed point numbers.
    int256 constant ONE_18 = 1e18;

    // Internally, intermediate values are computed with higher precision as 20 decimal fixed point numbers, and in the
    // case of ln36, 36 decimals.
    int256 constant ONE_20 = 1e20;
    int256 constant ONE_36 = 1e36;

    // The domain of natural exponentiation is bound by the word size and number of decimals used.
    //
    // Because internally the result will be stored using 20 decimals, the largest possible result is
    // (2^255 - 1) / 10^20, which makes the largest exponent ln((2^255 - 1) / 10^20) = 130.700829182905140221.
    // The smallest possible result is 10^(-18), which makes largest negative argument
    // ln(10^(-18)) = -41.446531673892822312.
    // We use 130.0 and -41.0 to have some safety margin.
    int256 constant MAX_NATURAL_EXPONENT = 130e18;
    int256 constant MIN_NATURAL_EXPONENT = -41e18;

    // 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
    // 256 bit integer.
    int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
    int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;

    uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20);

    // 18 decimal constants
    int256 constant x0 = 128000000000000000000; // 2ˆ7
    int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)
    int256 constant x1 = 64000000000000000000; // 2ˆ6
    int256 constant a1 = 6235149080811616882910000000; // eˆ(x1) (no decimals)

    // 20 decimal constants
    int256 constant x2 = 3200000000000000000000; // 2ˆ5
    int256 constant a2 = 7896296018268069516100000000000000; // eˆ(x2)
    int256 constant x3 = 1600000000000000000000; // 2ˆ4
    int256 constant a3 = 888611052050787263676000000; // eˆ(x3)
    int256 constant x4 = 800000000000000000000; // 2ˆ3
    int256 constant a4 = 298095798704172827474000; // eˆ(x4)
    int256 constant x5 = 400000000000000000000; // 2ˆ2
    int256 constant a5 = 5459815003314423907810; // eˆ(x5)
    int256 constant x6 = 200000000000000000000; // 2ˆ1
    int256 constant a6 = 738905609893065022723; // eˆ(x6)
    int256 constant x7 = 100000000000000000000; // 2ˆ0
    int256 constant a7 = 271828182845904523536; // eˆ(x7)
    int256 constant x8 = 50000000000000000000; // 2ˆ-1
    int256 constant a8 = 164872127070012814685; // eˆ(x8)
    int256 constant x9 = 25000000000000000000; // 2ˆ-2
    int256 constant a9 = 128402541668774148407; // eˆ(x9)
    int256 constant x10 = 12500000000000000000; // 2ˆ-3
    int256 constant a10 = 113314845306682631683; // eˆ(x10)
    int256 constant x11 = 6250000000000000000; // 2ˆ-4
    int256 constant a11 = 106449445891785942956; // eˆ(x11)

    /**
     * @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent.
     *
     * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.
     */
    function pow(uint256 x, uint256 y) internal pure returns (uint256) {
        if (y == 0) {
            // We solve the 0^0 indetermination by making it equal one.
            return uint256(ONE_18);
        }

        if (x == 0) {
            return 0;
        }

        // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to
        // arrive at that result. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means
        // x^y = exp(y * ln(x)).

        // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.
        _require(x < 2**255, Errors.X_OUT_OF_BOUNDS);
        int256 x_int256 = int256(x);

        // 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
        // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.

        // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.
        _require(y < MILD_EXPONENT_BOUND, Errors.Y_OUT_OF_BOUNDS);
        int256 y_int256 = int256(y);

        int256 logx_times_y;
        if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
            int256 ln_36_x = ln_36(x_int256);

            // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just
            // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal
            // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the
            // (downscaled) last 18 decimals.
            logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18);
        } else {
            logx_times_y = ln(x_int256) * y_int256;
        }
        logx_times_y /= ONE_18;

        // Finally, we compute exp(y * ln(x)) to arrive at x^y
        _require(
            MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
            Errors.PRODUCT_OUT_OF_BOUNDS
        );

        return uint256(exp(logx_times_y));
    }

    /**
     * @dev Natural exponentiation (e^x) with signed 18 decimal fixed point exponent.
     *
     * Reverts if `x` is smaller than MIN_NATURAL_EXPONENT, or larger than `MAX_NATURAL_EXPONENT`.
     */
    function exp(int256 x) internal pure returns (int256) {
        _require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, Errors.INVALID_EXPONENT);

        if (x < 0) {
            // We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since it
            // fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).
            // Fixed point division requires multiplying by ONE_18.
            return ((ONE_18 * ONE_18) / exp(-x));
        }

        // 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,
        // 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
        // because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the
        // decomposition.
        // 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
        // decomposition, which will be lower than the smallest x_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.
        // We mutate x by subtracting x_n, making it the remainder of the decomposition.

        // The first two a_n (e^(2^7) and e^(2^6)) are too large if stored as 18 decimal numbers, and could cause
        // intermediate overflows. Instead we store them as plain integers, with 0 decimals.
        // Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in the
        // decomposition.

        // For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so deduct
        // it and compute the accumulated product.

        int256 firstAN;
        if (x >= x0) {
            x -= x0;
            firstAN = a0;
        } else if (x >= x1) {
            x -= x1;
            firstAN = a1;
        } else {
            firstAN = 1; // One with no decimal places
        }

        // We now transform x into a 20 decimal fixed point number, to have enhanced precision when computing the
        // smaller terms.
        x *= 100;

        // `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed point
        // one. Recall that fixed point multiplication requires dividing by ONE_20.
        int256 product = ONE_20;

        if (x >= x2) {
            x -= x2;
            product = (product * a2) / ONE_20;
        }
        if (x >= x3) {
            x -= x3;
            product = (product * a3) / ONE_20;
        }
        if (x >= x4) {
            x -= x4;
            product = (product * a4) / ONE_20;
        }
        if (x >= x5) {
            x -= x5;
            product = (product * a5) / ONE_20;
        }
        if (x >= x6) {
            x -= x6;
            product = (product * a6) / ONE_20;
        }
        if (x >= x7) {
            x -= x7;
            product = (product * a7) / ONE_20;
        }
        if (x >= x8) {
            x -= x8;
            product = (product * a8) / ONE_20;
        }
        if (x >= x9) {
            x -= x9;
            product = (product * a9) / ONE_20;
        }

        // x10 and x11 are unnecessary here since we have high enough precision already.

        // Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor series
        // expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).

        int256 seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places.
        int256 term; // Each term in the sum, where the nth term is (x^n / n!).

        // The first term is simply x.
        term = x;
        seriesSum += term;

        // Each term (x^n / n!) equals the previous one times x, divided by n. Since x is a fixed point number,
        // multiplying by it requires dividing by ONE_20, but dividing by the non-fixed point n values does not.

        term = ((term * x) / ONE_20) / 2;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 3;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 4;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 5;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 6;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 7;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 8;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 9;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 10;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 11;
        seriesSum += term;

        term = ((term * x) / ONE_20) / 12;
        seriesSum += term;

        // 12 Taylor terms are sufficient for 18 decimal precision.

        // We now have the first a_n (with no decimals), and the product of all other a_n present, and the Taylor
        // approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to multiply
        // all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer multiplication),
        // and then drop two digits to return an 18 decimal value.

        return (((product * seriesSum) / ONE_20) * firstAN) / 100;
    }

    /**
     * @dev Natural logarithm (ln(a)) with signed 18 decimal fixed point argument.
     */
    function ln(int256 a) internal pure returns (int256) {
        // The real natural logarithm is not defined for negative numbers or zero.
        _require(a > 0, Errors.OUT_OF_BOUNDS);

        if (a < ONE_18) {
            // 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
            // than one, 1/a will be greater than one, and this if statement will not be entered in the recursive call.
            // Fixed point division requires multiplying by ONE_18.
            return (-ln((ONE_18 * ONE_18) / a));
        }

        // 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
        // we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n (that is,
        // ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers cannot
        // be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.
        // 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
        // decomposition, which will be lower than the smallest a_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.
        // We mutate a by subtracting a_n, making it the remainder of the decomposition.

        // 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
        // numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply them by
        // ONE_18 to convert them to fixed point.
        // For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so divide
        // by it and compute the accumulated sum.

        int256 sum = 0;
        if (a >= a0 * ONE_18) {
            a /= a0; // Integer, not fixed point division
            sum += x0;
        }

        if (a >= a1 * ONE_18) {
            a /= a1; // Integer, not fixed point division
            sum += x1;
        }

        // 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.
        sum *= 100;
        a *= 100;

        // Because further a_n are  20 digit fixed point numbers, we multiply by ONE_20 when dividing by them.

        if (a >= a2) {
            a = (a * ONE_20) / a2;
            sum += x2;
        }

        if (a >= a3) {
            a = (a * ONE_20) / a3;
            sum += x3;
        }

        if (a >= a4) {
            a = (a * ONE_20) / a4;
            sum += x4;
        }

        if (a >= a5) {
            a = (a * ONE_20) / a5;
            sum += x5;
        }

        if (a >= a6) {
            a = (a * ONE_20) / a6;
            sum += x6;
        }

        if (a >= a7) {
            a = (a * ONE_20) / a7;
            sum += x7;
        }

        if (a >= a8) {
            a = (a * ONE_20) / a8;
            sum += x8;
        }

        if (a >= a9) {
            a = (a * ONE_20) / a9;
            sum += x9;
        }

        if (a >= a10) {
            a = (a * ONE_20) / a10;
            sum += x10;
        }

        if (a >= a11) {
            a = (a * ONE_20) / a11;
            sum += x11;
        }

        // a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor series
        // that converges rapidly for values of `a` close to one - the same one used in ln_36.
        // Let z = (a - 1) / (a + 1).
        // ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))

        // Recall that 20 digit fixed point division requires multiplying by ONE_20, and multiplication requires
        // division by ONE_20.
        int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20);
        int256 z_squared = (z * z) / ONE_20;

        // num is the numerator of the series: the z^(2 * n + 1) term
        int256 num = z;

        // seriesSum holds the accumulated sum of each term in the series, starting with the initial z
        int256 seriesSum = num;

        // In each step, the numerator is multiplied by z^2
        num = (num * z_squared) / ONE_20;
        seriesSum += num / 3;

        num = (num * z_squared) / ONE_20;
        seriesSum += num / 5;

        num = (num * z_squared) / ONE_20;
        seriesSum += num / 7;

        num = (num * z_squared) / ONE_20;
        seriesSum += num / 9;

        num = (num * z_squared) / ONE_20;
        seriesSum += num / 11;

        // 6 Taylor terms are sufficient for 36 decimal precision.

        // Finally, we multiply by 2 (non fixed point) to compute ln(remainder)
        seriesSum *= 2;

        // We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder (both
        // with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18 decimal
        // value.

        return (sum + seriesSum) / 100;
    }

    /**
     * @dev Logarithm (log(arg, base), with signed 18 decimal fixed point base and argument argument.
     */
    function log(int256 arg, int256 base) internal pure returns (int256) {
        // This performs a simple base change: log(arg, base) = ln(arg) / ln(base).

        // Both logBase and logArg are computed as 36 decimal fixed point numbers, either by using ln_36, or by
        // upscaling.

        int256 logBase;
        if (LN_36_LOWER_BOUND < base && base < LN_36_UPPER_BOUND) {
            logBase = ln_36(base);
        } else {
            logBase = ln(base) * ONE_18;
        }

        int256 logArg;
        if (LN_36_LOWER_BOUND < arg && arg < LN_36_UPPER_BOUND) {
            logArg = ln_36(arg);
        } else {
            logArg = ln(arg) * ONE_18;
        }

        // When dividing, we multiply by ONE_18 to arrive at a result with 18 decimal places
        return (logArg * ONE_18) / logBase;
    }

    /**
     * @dev High precision (36 decimal places) natural logarithm (ln(x)) with signed 18 decimal fixed point argument,
     * for x close to one.
     *
     * Should only be used if x is between LN_36_LOWER_BOUND and LN_36_UPPER_BOUND.
     */
    function ln_36(int256 x) private pure returns (int256) {
        // Since ln(1) = 0, a value of x close to one will yield a very small result, which makes using 36 digits
        // worthwhile.

        // First, we transform x to a 36 digit fixed point value.
        x *= ONE_18;

        // We will use the following Taylor expansion, which converges very rapidly. Let z = (x - 1) / (x + 1).
        // ln(x) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))

        // Recall that 36 digit fixed point division requires multiplying by ONE_36, and multiplication requires
        // division by ONE_36.
        int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36);
        int256 z_squared = (z * z) / ONE_36;

        // num is the numerator of the series: the z^(2 * n + 1) term
        int256 num = z;

        // seriesSum holds the accumulated sum of each term in the series, starting with the initial z
        int256 seriesSum = num;

        // In each step, the numerator is multiplied by z^2
        num = (num * z_squared) / ONE_36;
        seriesSum += num / 3;

        num = (num * z_squared) / ONE_36;
        seriesSum += num / 5;

        num = (num * z_squared) / ONE_36;
        seriesSum += num / 7;

        num = (num * z_squared) / ONE_36;
        seriesSum += num / 9;

        num = (num * z_squared) / ONE_36;
        seriesSum += num / 11;

        num = (num * z_squared) / ONE_36;
        seriesSum += num / 13;

        num = (num * z_squared) / ONE_36;
        seriesSum += num / 15;

        // 8 Taylor terms are sufficient for 36 decimal precision.

        // All that remains is multiplying by 2 (non fixed point).
        return seriesSum * 2;
    }
}

pragma solidity 0.8.19;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow checks.
 * Adapted from OpenZeppelin's SafeMath library
 */
library Math {
    /**
     * @dev Returns the addition of two unsigned integers of 256 bits, reverting on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        _require(c >= a, Errors.ADD_OVERFLOW);
        return c;
    }

    /**
     * @dev Returns the addition of two signed integers, reverting on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        _require((b >= 0 && c >= a) || (b < 0 && c < a), Errors.ADD_OVERFLOW);
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers of 256 bits, reverting on overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        _require(b <= a, Errors.SUB_OVERFLOW);
        uint256 c = a - b;
        return c;
    }

    /**
     * @dev Returns the subtraction of two signed integers, reverting on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        _require((b >= 0 && c <= a) || (b < 0 && c > a), Errors.SUB_OVERFLOW);
        return c;
    }

    /**
     * @dev Returns the largest of two numbers of 256 bits.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers of 256 bits.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a * b;
        _require(a == 0 || c / a == b, Errors.MUL_OVERFLOW);
        return c;
    }

    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
        _require(b != 0, Errors.ZERO_DIVISION);
        return a / b;
    }

    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
        _require(b != 0, Errors.ZERO_DIVISION);

        if (a == 0) {
            return 0;
        } else {
            return 1 + (a - 1) / b;
        }
    }
}

pragma solidity 0.8.19;

library BalanceAllocation {
    using Math for uint256;

    // The 'cash' portion of the balance is stored in the least significant 112 bits of a 256 bit word, while the
    // 'managed' part uses the following 112 bits. The most significant 32 bits are used to store the block

    /**
     * @dev Returns the total amount of Pool tokens, including those that are not currently in the Vault ('managed').
     */
    function total(bytes32 balance) internal pure returns (uint256) {
        // Since 'cash' and 'managed' are 112 bit values, we don't need checked arithmetic. Additionally, `toBalance`
        // ensures that 'total' always fits in 112 bits.
        return cash(balance) + managed(balance);
    }

    /**
     * @dev Returns the amount of Pool tokens currently in the Vault.
     */
    function cash(bytes32 balance) internal pure returns (uint256) {
        uint256 mask = 2**(112) - 1;
        return uint256(balance) & mask;
    }

    /**
     * @dev Returns the amount of Pool tokens that are being managed by an Asset Manager.
     */
    function managed(bytes32 balance) internal pure returns (uint256) {
        uint256 mask = 2**(112) - 1;
        return uint256(balance >> 112) & mask;
    }

    /**
     * @dev Returns the last block when the total balance changed.
     */
    function lastChangeBlock(bytes32 balance) internal pure returns (uint256) {
        uint256 mask = 2**(32) - 1;
        return uint256(balance >> 224) & mask;
    }

    /**
     * @dev Returns the difference in 'managed' between two balances.
     */
    function managedDelta(bytes32 newBalance, bytes32 oldBalance) internal pure returns (int256) {
        // Because `managed` is a 112 bit value, we can safely perform unchecked arithmetic in 256 bits.
        return int256(managed(newBalance)) - int256(managed(oldBalance));
    }

    /**
     * @dev Returns the total balance for each entry in `balances`, as well as the latest block when the total
     * balance of *any* of them last changed.
     */
    function totalsAndLastChangeBlock(bytes32[] memory balances)
        internal
        pure
        returns (
            uint256[] memory results,
            uint256 lastChangeBlock_ // Avoid shadowing
        )
    {
        results = new uint256[](balances.length);
        lastChangeBlock_ = 0;

        for (uint256 i = 0; i < results.length; i++) {
            bytes32 balance = balances[i];
            results[i] = total(balance);
            lastChangeBlock_ = Math.max(lastChangeBlock_, lastChangeBlock(balance));
        }
    }

    /**
     * @dev Returns true if `balance`'s 'total' balance is zero. Costs less gas than computing 'total' and comparing
     * with zero.
     */
    function isZero(bytes32 balance) internal pure returns (bool) {
        // We simply need to check the least significant 224 bytes of the word: the block does not affect this.
        uint256 mask = 2**(224) - 1;
        return (uint256(balance) & mask) == 0;
    }

    /**
     * @dev Returns true if `balance`'s 'total' balance is not zero. Costs less gas than computing 'total' and comparing
     * with zero.
     */
    function isNotZero(bytes32 balance) internal pure returns (bool) {
        return !isZero(balance);
    }

    /**
     * @dev Packs together `cash` and `managed` amounts with a block to create a balance value.
     *
     * For consistency, this also checks that the sum of `cash` and `managed` (`total`) fits in 112 bits.
     */
    function toBalance(
        uint256 _cash,
        uint256 _managed,
        uint256 _blockNumber
    ) internal pure returns (bytes32) {
        uint256 _total = _cash + _managed;

        // Since both 'cash' and 'managed' are positive integers, by checking that their sum ('total') fits in 112 bits
        // we are also indirectly checking that both 'cash' and 'managed' themselves fit in 112 bits.
        _require(_total >= _cash && _total < 2**112, Errors.BALANCE_TOTAL_OVERFLOW);

        // We assume the block fits in 32 bits - this is expected to hold for at least a few decades.
        return _pack(_cash, _managed, _blockNumber);
    }

    /**
     * @dev Increases a Pool's 'cash' (and therefore its 'total'). Called when Pool tokens are sent to the Vault (except
     * for Asset Manager deposits).
     *
     * Updates the last total balance change block, even if `amount` is zero.
     */
    function increaseCash(bytes32 balance, uint256 amount) internal view returns (bytes32) {
        uint256 newCash = cash(balance).add(amount);
        uint256 currentManaged = managed(balance);
        uint256 newLastChangeBlock = block.number;

        return toBalance(newCash, currentManaged, newLastChangeBlock);
    }

    /**
     * @dev Decreases a Pool's 'cash' (and therefore its 'total'). Called when Pool tokens are sent from the Vault
     * (except for Asset Manager withdrawals).
     *
     * Updates the last total balance change block, even if `amount` is zero.
     */
    function decreaseCash(bytes32 balance, uint256 amount) internal view returns (bytes32) {
        uint256 newCash = cash(balance).sub(amount);
        uint256 currentManaged = managed(balance);
        uint256 newLastChangeBlock = block.number;

        return toBalance(newCash, currentManaged, newLastChangeBlock);
    }

    /**
     * @dev Moves 'cash' into 'managed', leaving 'total' unchanged. Called when an Asset Manager withdraws Pool tokens
     * from the Vault.
     */
    function cashToManaged(bytes32 balance, uint256 amount) internal pure returns (bytes32) {
        uint256 newCash = cash(balance).sub(amount);
        uint256 newManaged = managed(balance).add(amount);
        uint256 currentLastChangeBlock = lastChangeBlock(balance);

        return toBalance(newCash, newManaged, currentLastChangeBlock);
    }

    /**
     * @dev Moves 'managed' into 'cash', leaving 'total' unchanged. Called when an Asset Manager deposits Pool tokens
     * into the Vault.
     */
    function managedToCash(bytes32 balance, uint256 amount) internal pure returns (bytes32) {
        uint256 newCash = cash(balance).add(amount);
        uint256 newManaged = managed(balance).sub(amount);
        uint256 currentLastChangeBlock = lastChangeBlock(balance);

        return toBalance(newCash, newManaged, currentLastChangeBlock);
    }

    /**
     * @dev Sets 'managed' balance to an arbitrary value, changing 'total'. Called when the Asset Manager reports
     * profits or losses. It's the Manager's responsibility to provide a meaningful value.
     *
     * Updates the last total balance change block, even if `newManaged` is equal to the current 'managed' value.
     */
    function setManaged(bytes32 balance, uint256 newManaged) internal view returns (bytes32) {
        uint256 currentCash = cash(balance);
        uint256 newLastChangeBlock = block.number;
        return toBalance(currentCash, newManaged, newLastChangeBlock);
    }

    // Alternative mode for Pools with the Two Token specialization setting

    // Instead of storing cash and external for each 'token in' a single storage slot, Two Token Pools store the cash
    // for both tokens in the same slot, and the managed for both in another one. This reduces the gas cost for swaps,
    // because the only slot that needs to be updated is the one with the cash. However, it also means that managing
    // balances is more cumbersome, as both tokens need to be read/written at the same time.
    //
    // The field with both cash balances packed is called sharedCash, and the one with external amounts is called
    // sharedManaged. These two are collectively called the 'shared' balance fields. In both of these, the portion
    // that corresponds to token A is stored in the least significant 112 bits of a 256 bit word, while token B's part
    // uses the next least significant 112 bits.
    //
    // Because only cash is written to during a swap, we store the last total balance change block with the
    // packed cash fields. Typically Pools have a distinct block per token: in the case of Two Token Pools they
    // are the same.

    /**
     * @dev Extracts the part of the balance that corresponds to token A. This function can be used to decode both
     * shared cash and managed balances.
     */
    function _decodeBalanceA(bytes32 sharedBalance) private pure returns (uint256) {
        uint256 mask = 2**(112) - 1;
        return uint256(sharedBalance) & mask;
    }

    /**
     * @dev Extracts the part of the balance that corresponds to token B. This function can be used to decode both
     * shared cash and managed balances.
     */
    function _decodeBalanceB(bytes32 sharedBalance) private pure returns (uint256) {
        uint256 mask = 2**(112) - 1;
        return uint256(sharedBalance >> 112) & mask;
    }

    // To decode the last balance change block, we can simply use the `blockNumber` function.

    /**
     * @dev Unpacks the shared token A and token B cash and managed balances into the balance for token A.
     */
    function fromSharedToBalanceA(bytes32 sharedCash, bytes32 sharedManaged) internal pure returns (bytes32) {
        // Note that we extract the block from the sharedCash field, which is the one that is updated by swaps.
        // Both token A and token B use the same block
        return toBalance(_decodeBalanceA(sharedCash), _decodeBalanceA(sharedManaged), lastChangeBlock(sharedCash));
    }

    /**
     * @dev Unpacks the shared token A and token B cash and managed balances into the balance for token B.
     */
    function fromSharedToBalanceB(bytes32 sharedCash, bytes32 sharedManaged) internal pure returns (bytes32) {
        // Note that we extract the block from the sharedCash field, which is the one that is updated by swaps.
        // Both token A and token B use the same block
        return toBalance(_decodeBalanceB(sharedCash), _decodeBalanceB(sharedManaged), lastChangeBlock(sharedCash));
    }

    /**
     * @dev Returns the sharedCash shared field, given the current balances for token A and token B.
     */
    function toSharedCash(bytes32 tokenABalance, bytes32 tokenBBalance) internal pure returns (bytes32) {
        // Both balances are assigned the same block  Since it is possible a single one of them has changed (for
        // example, in an Asset Manager update), we keep the latest (largest) one.
        uint32 newLastChangeBlock = uint32(Math.max(lastChangeBlock(tokenABalance), lastChangeBlock(tokenBBalance)));

        return _pack(cash(tokenABalance), cash(tokenBBalance), newLastChangeBlock);
    }

    /**
     * @dev Returns the sharedManaged shared field, given the current balances for token A and token B.
     */
    function toSharedManaged(bytes32 tokenABalance, bytes32 tokenBBalance) internal pure returns (bytes32) {
        // We don't bother storing a last change block, as it is read from the shared cash field.
        return _pack(managed(tokenABalance), managed(tokenBBalance), 0);
    }

    // Shared functions

    /**
     * @dev Packs together two uint112 and one uint32 into a bytes32
     */
    function _pack(
        uint256 _leastSignificant,
        uint256 _midSignificant,
        uint256 _mostSignificant
    ) private pure returns (bytes32) {
        return bytes32((_mostSignificant << 224) + (_midSignificant << 112) + _leastSignificant);
    }
}

pragma solidity 0.8.19;

// Based on the ReentrancyGuard library from OpenZeppelin contracts, altered to reduce bytecode size.
// Modifier code is inlined by the compiler, which causes its code to appear multiple times in the codebase. By using
// private functions, we achieve the same end result with slightly higher runtime gas costs but reduced bytecode size.

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _enterNonReentrant();
        _;
        _exitNonReentrant();
    }

    function _enterNonReentrant() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        _require(_status != _ENTERED, Errors.REENTRANCY);

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _exitNonReentrant() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

pragma solidity 0.8.19;

/**
 * @dev Full external interface for the Vault core contract - no external or public methods exist in the contract that
 * don't override one of these declarations.
 */
interface IVault is ISignaturesValidator, ITemporarilyPausable {
    // Generalities about the Vault:
    //
    // - Whenever documentation refers to 'tokens', it strictly refers to ERC20-compliant token contracts. Tokens are
    // transferred out of the Vault by calling the `IERC20.transfer` function, and transferred in by calling
    // `IERC20.transferFrom`. In these cases, the sender must have previously allowed the Vault to use their tokens by
    // calling `IERC20.approve`. The only deviation from the ERC20 standard that is supported is functions not returning
    // a boolean value: in these scenarios, a non-reverting call is assumed to be successful.
    //
    // - All non-view functions in the Vault are non-reentrant: calling them while another one is mid-execution (e.g.
    // while execution control is transferred to a token contract during a swap) will result in a revert. View
    // functions can be called in a re-reentrant way, but doing so might cause them to return inconsistent results.
    // Contracts calling view functions in the Vault must make sure the Vault has not already been entered.
    //
    // - View functions revert if referring to either unregistered Pools, or unregistered tokens for registered Pools.

    // Authorizer
    //
    // Some system actions are permissioned, like setting and collecting protocol fees. This permissioning system exists
    // outside of the Vault in the Authorizer contract: the Vault simply calls the Authorizer to check if the caller
    // can perform a given action.

    /**
     * @dev Returns the Vault's Authorizer.
     */
    function getAuthorizer() external view returns (IAuthorizer);

    /**
     * @dev Sets a new Authorizer for the Vault. The caller must be allowed by the current Authorizer to do this.
     *
     * Emits an `AuthorizerChanged` event.
     */
    function setAuthorizer(IAuthorizer newAuthorizer) external;

    /**
     * @dev Emitted when a new authorizer is set by `setAuthorizer`.
     */
    event AuthorizerChanged(IAuthorizer indexed newAuthorizer);

    // Relayers
    //
    // Additionally, it is possible for an account to perform certain actions on behalf of another one, using their
    // Vault ERC20 allowance and Internal Balance. These accounts are said to be 'relayers' for these Vault functions,
    // and are expected to be smart contracts with sound authentication mechanisms. For an account to be able to wield
    // this power, two things must occur:
    //  - The Authorizer must grant the account the permission to be a relayer for the relevant Vault function. This
    //    means that Balancer governance must approve each individual contract to act as a relayer for the intended
    //    functions.
    //  - Each user must approve the relayer to act on their behalf.
    // This double protection means users cannot be tricked into approving malicious relayers (because they will not
    // have been allowed by the Authorizer via governance), nor can malicious relayers approved by a compromised
    // Authorizer or governance drain user funds, since they would also need to be approved by each individual user.

    /**
     * @dev Returns true if `user` has approved `relayer` to act as a relayer for them.
     */
    function hasApprovedRelayer(address user, address relayer) external view returns (bool);

    /**
     * @dev Allows `relayer` to act as a relayer for `sender` if `approved` is true, and disallows it otherwise.
     *
     * Emits a `RelayerApprovalChanged` event.
     */
    function setRelayerApproval(
        address sender,
        address relayer,
        bool approved
    ) external;

    /**
     * @dev Emitted every time a relayer is approved or disapproved by `setRelayerApproval`.
     */
    event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved);

    // Internal Balance
    //
    // Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later
    // transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination
    // when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced
    // gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users.
    //
    // Internal Balance management features batching, which means a single contract call can be used to perform multiple
    // operations of different kinds, with different senders and recipients, at once.

    /**
     * @dev Returns `user`'s Internal Balance for a set of tokens.
     */
    function getInternalBalance(address user, IERC20[] memory tokens) external view returns (uint256[] memory);

    /**
     * @dev Performs a set of user balance operations, which involve Internal Balance (deposit, withdraw or transfer)
     * and plain ERC20 transfers using the Vault's allowance. This last feature is particularly useful for relayers, as
     * it lets integrators reuse a user's Vault allowance.
     *
     * For each operation, if the caller is not `sender`, it must be an authorized relayer for them.
     */
    function manageUserBalance(UserBalanceOp[] memory ops) external payable;

    /**
     * @dev Data for `manageUserBalance` operations, which include the possibility for ETH to be sent and received
     without manual WETH wrapping or unwrapping.
     */
    struct UserBalanceOp {
        UserBalanceOpKind kind;
        IAsset asset;
        uint256 amount;
        address sender;
        address payable recipient;
    }

    // There are four possible operations in `manageUserBalance`:
    //
    // - DEPOSIT_INTERNAL
    // Increases the Internal Balance of the `recipient` account by transferring tokens from the corresponding
    // `sender`. The sender must have allowed the Vault to use their tokens via `IERC20.approve()`.
    //
    // ETH can be used by passing the ETH sentinel value as the asset and forwarding ETH in the call: it will be wrapped
    // and deposited as WETH. Any ETH amount remaining will be sent back to the caller (not the sender, which is
    // relevant for relayers).
    //
    // Emits an `InternalBalanceChanged` event.
    //
    //
    // - WITHDRAW_INTERNAL
    // Decreases the Internal Balance of the `sender` account by transferring tokens to the `recipient`.
    //
    // ETH can be used by passing the ETH sentinel value as the asset. This will deduct WETH instead, unwrap it and send
    // it to the recipient as ETH.
    //
    // Emits an `InternalBalanceChanged` event.
    //
    //
    // - TRANSFER_INTERNAL
    // Transfers tokens from the Internal Balance of the `sender` account to the Internal Balance of `recipient`.
    //
    // Reverts if the ETH sentinel value is passed.
    //
    // Emits an `InternalBalanceChanged` event.
    //
    //
    // - TRANSFER_EXTERNAL
    // Transfers tokens from `sender` to `recipient`, using the Vault's ERC20 allowance. This is typically used by
    // relayers, as it lets them reuse a user's Vault allowance.
    //
    // Reverts if the ETH sentinel value is passed.
    //
    // Emits an `ExternalBalanceTransfer` event.

    enum UserBalanceOpKind { DEPOSIT_INTERNAL, WITHDRAW_INTERNAL, TRANSFER_INTERNAL, TRANSFER_EXTERNAL }

    /**
     * @dev Emitted when a user's Internal Balance changes, either from calls to `manageUserBalance`, or through
     * interacting with Pools using Internal Balance.
     *
     * Because Internal Balance works exclusively with ERC20 tokens, ETH deposits and withdrawals will use the WETH
     * address.
     */
    event InternalBalanceChanged(address indexed user, IERC20 indexed token, int256 delta);

    /**
     * @dev Emitted when a user's Vault ERC20 allowance is used by the Vault to transfer tokens to an external account.
     */
    event ExternalBalanceTransfer(IERC20 indexed token, address indexed sender, address recipient, uint256 amount);

    // Pools
    //
    // There are three specialization settings for Pools, which allow for cheaper swaps at the cost of reduced
    // functionality:
    //
    //  - General: no specialization, suited for all Pools. IGeneralPool is used for swap request callbacks, passing the
    // balance of all tokens in the Pool. These Pools have the largest swap costs (because of the extra storage reads),
    // which increase with the number of registered tokens.
    //
    //  - Minimal Swap Info: IMinimalSwapInfoPool is used instead of IGeneralPool, which saves gas by only passing the
    // balance of the two tokens involved in the swap. This is suitable for some pricing algorithms, like the weighted
    // constant product one popularized by Balancer V1. Swap costs are smaller compared to general Pools, and are
    // independent of the number of registered tokens.
    //
    //  - Two Token: only allows two tokens to be registered. This achieves the lowest possible swap gas cost. Like
    // minimal swap info Pools, these are called via IMinimalSwapInfoPool.

    enum PoolSpecialization { GENERAL, MINIMAL_SWAP_INFO, TWO_TOKEN }

    /**
     * @dev Registers the caller account as a Pool with a given specialization setting. Returns the Pool's ID, which
     * is used in all Pool-related functions. Pools cannot be deregistered, nor can the Pool's specialization be
     * changed.
     *
     * The caller is expected to be a smart contract that implements either `IGeneralPool` or `IMinimalSwapInfoPool`,
     * depending on the chosen specialization setting. This contract is known as the Pool's contract.
     *
     * Note that the same contract may register itself as multiple Pools with unique Pool IDs, or in other words,
     * multiple Pools may share the same contract.
     *
     * Emits a `PoolRegistered` event.
     */
    function registerPool(PoolSpecialization specialization) external returns (bytes32);

    /**
     * @dev Emitted when a Pool is registered by calling `registerPool`.
     */
    event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, PoolSpecialization specialization);

    /**
     * @dev Returns a Pool's contract address and specialization setting.
     */
    function getPool(bytes32 poolId) external view returns (address, PoolSpecialization);

    /**
     * @dev Registers `tokens` for the `poolId` Pool. Must be called by the Pool's contract.
     *
     * Pools can only interact with tokens they have registered. Users join a Pool by transferring registered tokens,
     * exit by receiving registered tokens, and can only swap registered tokens.
     *
     * Each token can only be registered once. For Pools with the Two Token specialization, `tokens` must have a length
     * of two, that is, both tokens must be registered in the same `registerTokens` call, and they must be sorted in
     * ascending order.
     *
     * The `tokens` and `assetManagers` arrays must have the same length, and each entry in these indicates the Asset
     * Manager for the corresponding token. Asset Managers can manage a Pool's tokens via `managePoolBalance`,
     * depositing and withdrawing them directly, and can even set their balance to arbitrary amounts. They are therefore
     * expected to be highly secured smart contracts with sound design principles, and the decision to register an
     * Asset Manager should not be made lightly.
     *
     * Pools can choose not to assign an Asset Manager to a given token by passing in the zero address. Once an Asset
     * Manager is set, it cannot be changed except by deregistering the associated token and registering again with a
     * different Asset Manager.
     *
     * Emits a `TokensRegistered` event.
     */
    function registerTokens(
        bytes32 poolId,
        IERC20[] memory tokens,
        address[] memory assetManagers
    ) external;

    /**
     * @dev Emitted when a Pool registers tokens by calling `registerTokens`.
     */
    event TokensRegistered(bytes32 indexed poolId, IERC20[] tokens, address[] assetManagers);

    /**
     * @dev Deregisters `tokens` for the `poolId` Pool. Must be called by the Pool's contract.
     *
     * Only registered tokens (via `registerTokens`) can be deregistered. Additionally, they must have zero total
     * balance. For Pools with the Two Token specialization, `tokens` must have a length of two, that is, both tokens
     * must be deregistered in the same `deregisterTokens` call.
     *
     * A deregistered token can be re-registered later on, possibly with a different Asset Manager.
     *
     * Emits a `TokensDeregistered` event.
     */
    function deregisterTokens(bytes32 poolId, IERC20[] memory tokens) external;

    /**
     * @dev Emitted when a Pool deregisters tokens by calling `deregisterTokens`.
     */
    event TokensDeregistered(bytes32 indexed poolId, IERC20[] tokens);

    /**
     * @dev Returns detailed information for a Pool's registered token.
     *
     * `cash` is the number of tokens the Vault currently holds for the Pool. `managed` is the number of tokens
     * withdrawn and held outside the Vault by the Pool's token Asset Manager. The Pool's total balance for `token`
     * equals the sum of `cash` and `managed`.
     *
     * Internally, `cash` and `managed` are stored using 112 bits. No action can ever cause a Pool's token `cash`,
     * `managed` or `total` balance to be greater than 2^112 - 1.
     *
     * `lastChangeBlock` is the number of the block in which `token`'s total balance was last modified (via either a
     * join, exit, swap, or Asset Manager update). This value is useful to avoid so-called 'sandwich attacks', for
     * example when developing price oracles. A change of zero (e.g. caused by a swap with amount zero) is considered a
     * change for this purpose, and will update `lastChangeBlock`.
     *
     * `assetManager` is the Pool's token Asset Manager.
     */
    function getPoolTokenInfo(bytes32 poolId, IERC20 token)
        external
        view
        returns (
            uint256 cash,
            uint256 managed,
            uint256 lastChangeBlock,
            address assetManager
        );

    /**
     * @dev Returns a Pool's registered tokens, the total balance for each, and the latest block when *any* of
     * the tokens' `balances` changed.
     *
     * The order of the `tokens` array is the same order that will be used in `joinPool`, `exitPool`, as well as in all
     * Pool hooks (where applicable). Calls to `registerTokens` and `deregisterTokens` may change this order.
     *
     * If a Pool only registers tokens once, and these are sorted in ascending order, they will be stored in the same
     * order as passed to `registerTokens`.
     *
     * Total balances include both tokens held by the Vault and those withdrawn by the Pool's Asset Managers. These are
     * the amounts used by joins, exits and swaps. For a detailed breakdown of token balances, use `getPoolTokenInfo`
     * instead.
     */
    function getPoolTokens(bytes32 poolId)
        external
        view
        returns (
            IERC20[] memory tokens,
            uint256[] memory balances,
            uint256 lastChangeBlock
        );

    /**
     * @dev Called by users to join a Pool, which transfers tokens from `sender` into the Pool's balance. This will
     * trigger custom Pool behavior, which will typically grant something in return to `recipient` - often tokenized
     * Pool shares.
     *
     * If the caller is not `sender`, it must be an authorized relayer for them.
     *
     * The `assets` and `maxAmountsIn` arrays must have the same length, and each entry indicates the maximum amount
     * to send for each asset. The amounts to send are decided by the Pool and not the Vault: it just enforces
     * these maximums.
     *
     * If joining a Pool that holds WETH, it is possible to send ETH directly: the Vault will do the wrapping. To enable
     * this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead of the
     * WETH address. Note that it is not possible to combine ETH and WETH in the same join. Any excess ETH will be sent
     * back to the caller (not the sender, which is important for relayers).
     *
     * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when
     * interacting with Pools that register and deregister tokens frequently. If sending ETH however, the array must be
     * sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the final
     * `assets` array might not be sorted. Pools with no registered tokens cannot be joined.
     *
     * If `fromInternalBalance` is true, the caller's Internal Balance will be preferred: ERC20 transfers will only
     * be made for the difference between the requested amount and Internal Balance (if any). Note that ETH cannot be
     * withdrawn from Internal Balance: attempting to do so will trigger a revert.
     *
     * This causes the Vault to call the `IBasePool.onJoinPool` hook on the Pool's contract, where Pools implement
     * their own custom logic. This typically requires additional information from the user (such as the expected number
     * of Pool shares). This can be encoded in the `userData` argument, which is ignored by the Vault and passed
     * directly to the Pool's contract, as is `recipient`.
     *
     * Emits a `PoolBalanceChanged` event.
     */
    function joinPool(
        bytes32 poolId,
        address sender,
        address recipient,
        JoinPoolRequest memory request
    ) external payable;

    struct JoinPoolRequest {
        IAsset[] assets;
        uint256[] maxAmountsIn;
        bytes userData;
        bool fromInternalBalance;
    }

    /**
     * @dev Called by users to exit a Pool, which transfers tokens from the Pool's balance to `recipient`. This will
     * trigger custom Pool behavior, which will typically ask for something in return from `sender` - often tokenized
     * Pool shares. The amount of tokens that can be withdrawn is limited by the Pool's `cash` balance (see
     * `getPoolTokenInfo`).
     *
     * If the caller is not `sender`, it must be an authorized relayer for them.
     *
     * The `tokens` and `minAmountsOut` arrays must have the same length, and each entry in these indicates the minimum
     * token amount to receive for each token contract. The amounts to send are decided by the Pool and not the Vault:
     * it just enforces these minimums.
     *
     * If exiting a Pool that holds WETH, it is possible to receive ETH directly: the Vault will do the unwrapping. To
     * enable this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead
     * of the WETH address. Note that it is not possible to combine ETH and WETH in the same exit.
     *
     * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when
     * interacting with Pools that register and deregister tokens frequently. If receiving ETH however, the array must
     * be sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the
     * final `assets` array might not be sorted. Pools with no registered tokens cannot be exited.
     *
     * If `toInternalBalance` is true, the tokens will be deposited to `recipient`'s Internal Balance. Otherwise,
     * an ERC20 transfer will be performed. Note that ETH cannot be deposited to Internal Balance: attempting to
     * do so will trigger a revert.
     *
     * `minAmountsOut` is the minimum amount of tokens the user expects to get out of the Pool, for each token in the
     * `tokens` array. This array must match the Pool's registered tokens.
     *
     * This causes the Vault to call the `IBasePool.onExitPool` hook on the Pool's contract, where Pools implement
     * their own custom logic. This typically requires additional information from the user (such as the expected number
     * of Pool shares to return). This can be encoded in the `userData` argument, which is ignored by the Vault and
     * passed directly to the Pool's contract.
     *
     * Emits a `PoolBalanceChanged` event.
     */
    function exitPool(
        bytes32 poolId,
        address sender,
        address payable recipient,
        ExitPoolRequest memory request
    ) external;

    struct ExitPoolRequest {
        IAsset[] assets;
        uint256[] minAmountsOut;
        bytes userData;
        bool toInternalBalance;
    }

    /**
     * @dev Emitted when a user joins or exits a Pool by calling `joinPool` or `exitPool`, respectively.
     */
    event PoolBalanceChanged(
        bytes32 indexed poolId,
        address indexed liquidityProvider,
        IERC20[] tokens,
        int256[] deltas,
        uint256[] protocolFeeAmounts
    );

    enum PoolBalanceChangeKind { JOIN, EXIT }

    // Swaps
    //
    // Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. To do this,
    // they need not trust Pool contracts in any way: all security checks are made by the Vault. They must however be
    // aware of the Pools' pricing algorithms in order to estimate the prices Pools will quote.
    //
    // The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence.
    // In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'),
    // and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out').
    // More complex swaps, such as one token in to multiple tokens out can be achieved by batching together
    // individual swaps.
    //
    // There are two swap kinds:
    //  - 'given in' swaps, where the amount of tokens in (sent to the Pool) is known, and the Pool determines (via the
    // `onSwap` hook) the amount of tokens out (to send to the recipient).
    //  - 'given out' swaps, where the amount of tokens out (received from the Pool) is known, and the Pool determines
    // (via the `onSwap` hook) the amount of tokens in (to receive from the sender).
    //
    // Additionally, it is possible to chain swaps using a placeholder input amount, which the Vault replaces with
    // the calculated output of the previous swap. If the previous swap was 'given in', this will be the calculated
    // tokenOut amount. If the previous swap was 'given out', it will use the calculated tokenIn amount. These extended
    // swaps are known as 'multihop' swaps, since they 'hop' through a number of intermediate tokens before arriving at
    // the final intended token.
    //
    // In all cases, tokens are only transferred in and out of the Vault (or withdrawn from and deposited into Internal
    // Balance) after all individual swaps have been completed, and the net token balance change computed. This makes
    // certain swap patterns, such as multihops, or swaps that interact with the same token pair in multiple Pools, cost
    // much less gas than they would otherwise.
    //
    // It also means that under certain conditions it is possible to perform arbitrage by swapping with multiple
    // Pools in a way that results in net token movement out of the Vault (profit), with no tokens being sent in (only
    // updating the Pool's internal accounting).
    //
    // To protect users from front-running or the market changing rapidly, they supply a list of 'limits' for each token
    // involved in the swap, where either the maximum number of tokens to send (by passing a positive value) or the
    // minimum amount of tokens to receive (by passing a negative value) is specified.
    //
    // Additionally, a 'deadline' timestamp can also be provided, forcing the swap to fail if it occurs after
    // this point in time (e.g. if the transaction failed to be included in a block promptly).
    //
    // If interacting with Pools that hold WETH, it is possible to both send and receive ETH directly: the Vault will do
    // the wrapping and unwrapping. To enable this mechanism, the IAsset sentinel value (the zero address) must be
    // passed in the `assets` array instead of the WETH address. Note that it is possible to combine ETH and WETH in the
    // same swap. Any excess ETH will be sent back to the caller (not the sender, which is relevant for relayers).
    //
    // Finally, Internal Balance can be used when either sending or receiving tokens.

    enum SwapKind { GIVEN_IN, GIVEN_OUT }

    /**
     * @dev Performs a swap with a single Pool.
     *
     * If the swap is 'given in' (the number of tokens to send to the Pool is known), it returns the amount of tokens
     * taken from the Pool, which must be greater than or equal to `limit`.
     *
     * If the swap is 'given out' (the number of tokens to take from the Pool is known), it returns the amount of tokens
     * sent to the Pool, which must be less than or equal to `limit`.
     *
     * Internal Balance usage and the recipient are determined by the `funds` struct.
     *
     * Emits a `Swap` event.
     */
    function swap(
        SingleSwap memory singleSwap,
        FundManagement memory funds,
        uint256 limit,
        uint256 deadline
    ) external payable returns (uint256);

    /**
     * @dev Data for a single swap executed by `swap`. `amount` is either `amountIn` or `amountOut` depending on
     * the `kind` value.
     *
     * `assetIn` and `assetOut` are either token addresses, or the IAsset sentinel value for ETH (the zero address).
     * Note that Pools never interact with ETH directly: it will be wrapped to or unwrapped from WETH by the Vault.
     *
     * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be
     * used to extend swap behavior.
     */
    struct SingleSwap {
        bytes32 poolId;
        SwapKind kind;
        IAsset assetIn;
        IAsset assetOut;
        uint256 amount;
        bytes userData;
    }

    /**
     * @dev Performs a series of swaps with one or multiple Pools. In each individual swap, the caller determines either
     * the amount of tokens sent to or received from the Pool, depending on the `kind` value.
     *
     * Returns an array with the net Vault asset balance deltas. Positive amounts represent tokens (or ETH) sent to the
     * Vault, and negative amounts represent tokens (or ETH) sent by the Vault. Each delta corresponds to the asset at
     * the same index in the `assets` array.
     *
     * Swaps are executed sequentially, in the order specified by the `swaps` array. Each array element describes a
     * Pool, the token to be sent to this Pool, the token to receive from it, and an amount that is either `amountIn` or
     * `amountOut` depending on the swap kind.
     *
     * Multihop swaps can be executed by passing an `amount` value of zero for a swap. This will cause the amount in/out
     * of the previous swap to be used as the amount in for the current one. In a 'given in' swap, 'tokenIn' must equal
     * the previous swap's `tokenOut`. For a 'given out' swap, `tokenOut` must equal the previous swap's `tokenIn`.
     *
     * The `assets` array contains the addresses of all assets involved in the swaps. These are either token addresses,
     * or the IAsset sentinel value for ETH (the zero address). Each entry in the `swaps` array specifies tokens in and
     * out by referencing an index in `assets`. Note that Pools never interact with ETH directly: it will be wrapped to
     * or unwrapped from WETH by the Vault.
     *
     * Internal Balance usage, sender, and recipient are determined by the `funds` struct. The `limits` array specifies
     * the minimum or maximum amount of each token the vault is allowed to transfer.
     *
     * `batchSwap` can be used to make a single swap, like `swap` does, but doing so requires more gas than the
     * equivalent `swap` call.
     *
     * Emits `Swap` events.
     */
    function batchSwap(
        SwapKind kind,
        BatchSwapStep[] memory swaps,
        IAsset[] memory assets,
        FundManagement memory funds,
        int256[] memory limits,
        uint256 deadline
    ) external payable returns (int256[] memory);

    /**
     * @dev Data for each individual swap executed by `batchSwap`. The asset in and out fields are indexes into the
     * `assets` array passed to that function, and ETH assets are converted to WETH.
     *
     * If `amount` is zero, the multihop mechanism is used to determine the actual amount based on the amount in/out
     * from the previous swap, depending on the swap kind.
     *
     * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be
     * used to extend swap behavior.
     */
    struct BatchSwapStep {
        bytes32 poolId;
        uint256 assetInIndex;
        uint256 assetOutIndex;
        uint256 amount;
        bytes userData;
    }

    /**
     * @dev Emitted for each individual swap performed by `swap` or `batchSwap`.
     */
    event Swap(
        bytes32 indexed poolId,
        IERC20 indexed tokenIn,
        IERC20 indexed tokenOut,
        uint256 amountIn,
        uint256 amountOut
    );

    /**
     * @dev All tokens in a swap are either sent from the `sender` account to the Vault, or from the Vault to the
     * `recipient` account.
     *
     * If the caller is not `sender`, it must be an authorized relayer for them.
     *
     * If `fromInternalBalance` is true, the `sender`'s Internal Balance will be preferred, performing an ERC20
     * transfer for the difference between the requested amount and the User's Internal Balance (if any). The `sender`
     * must have allowed the Vault to use their tokens via `IERC20.approve()`. This matches the behavior of
     * `joinPool`.
     *
     * If `toInternalBalance` is true, tokens will be deposited to `recipient`'s internal balance instead of
     * transferred. This matches the behavior of `exitPool`.
     *
     * Note that ETH cannot be deposited to or withdrawn from Internal Balance: attempting to do so will trigger a
     * revert.
     */
    struct FundManagement {
        address sender;
        bool fromInternalBalance;
        address payable recipient;
        bool toInternalBalance;
    }

    /**
     * @dev Simulates a call to `batchSwap`, returning an array of Vault asset deltas. Calls to `swap` cannot be
     * simulated directly, but an equivalent `batchSwap` call can and will yield the exact same result.
     *
     * Each element in the array corresponds to the asset at the same index, and indicates the number of tokens (or ETH)
     * the Vault would take from the sender (if positive) or send to the recipient (if negative). The arguments it
     * receives are the same that an equivalent `batchSwap` call would receive.
     *
     * Unlike `batchSwap`, this function performs no checks on the sender or recipient field in the `funds` struct.
     * This makes it suitable to be called by off-chain applications via eth_call without needing to hold tokens,
     * approve them for the Vault, or even know a user's address.
     *
     * Note that this function is not 'view' (due to implementation details): the client code must explicitly execute
     * eth_call instead of eth_sendTransaction.
     */
    function queryBatchSwap(
        SwapKind kind,
        BatchSwapStep[] memory swaps,
        IAsset[] memory assets,
        FundManagement memory funds
    ) external returns (int256[] memory assetDeltas);

    // Flash Loans

    /**
     * @dev Performs a 'flash loan', sending tokens to `recipient`, executing the `receiveFlashLoan` hook on it,
     * and then reverting unless the tokens plus a proportional protocol fee have been returned.
     *
     * The `tokens` and `amounts` arrays must have the same length, and each entry in these indicates the loan amount
     * for each token contract. `tokens` must be sorted in ascending order.
     *
     * The 'userData' field is ignored by the Vault, and forwarded as-is to `recipient` as part of the
     * `receiveFlashLoan` call.
     *
     * Emits `FlashLoan` events.
     */
    function flashLoan(
        IFlashLoanRecipient recipient,
        IERC20[] memory tokens,
        uint256[] memory amounts,
        bytes memory userData
    ) external;

    /**
     * @dev Emitted for each individual flash loan performed by `flashLoan`.
     */
    event FlashLoan(IFlashLoanRecipient indexed recipient, IERC20 indexed token, uint256 amount, uint256 feeAmount);

    // Asset Management
    //
    // Each token registered for a Pool can be assigned an Asset Manager, which is able to freely withdraw the Pool's
    // tokens from the Vault, deposit them, or assign arbitrary values to its `managed` balance (see
    // `getPoolTokenInfo`). This makes them extremely powerful and dangerous. Even if an Asset Manager only directly
    // controls one of the tokens in a Pool, a malicious manager could set that token's balance to manipulate the
    // prices of the other tokens, and then drain the Pool with swaps. The risk of using Asset Managers is therefore
    // not constrained to the tokens they are managing, but extends to the entire Pool's holdings.
    //
    // However, a properly designed Asset Manager smart contract can be safely used for the Pool's benefit,
    // for example by lending unused tokens out for interest, or using them to participate in voting protocols.
    //
    // This concept is unrelated to the IAsset interface.

    /**
     * @dev Performs a set of Pool balance operations, which may be either withdrawals, deposits or updates.
     *
     * Pool Balance management features batching, which means a single contract call can be used to perform multiple
     * operations of different kinds, with different Pools and tokens, at once.
     *
     * For each operation, the caller must be registered as the Asset Manager for `token` in `poolId`.
     */
    function managePoolBalance(PoolBalanceOp[] memory ops) external;

    struct PoolBalanceOp {
        PoolBalanceOpKind kind;
        bytes32 poolId;
        IERC20 token;
        uint256 amount;
    }

    /**
     * Withdrawals decrease the Pool's cash, but increase its managed balance, leaving the total balance unchanged.
     *
     * Deposits increase the Pool's cash, but decrease its managed balance, leaving the total balance unchanged.
     *
     * Updates don't affect the Pool's cash balance, but because the managed balance changes, it does alter the total.
     * The external amount can be either increased or decreased by this call (i.e., reporting a gain or a loss).
     */
    enum PoolBalanceOpKind { WITHDRAW, DEPOSIT, UPDATE }

    /**
     * @dev Emitted when a Pool's token Asset Manager alters its balance via `managePoolBalance`.
     */
    event PoolBalanceManaged(
        bytes32 indexed poolId,
        address indexed assetManager,
        IERC20 indexed token,
        int256 cashDelta,
        int256 managedDelta
    );

    // Protocol Fees
    //
    // Some operations cause the Vault to collect tokens in the form of protocol fees, which can then be withdrawn by
    // permissioned accounts.
    //
    // There are two kinds of protocol fees:
    //
    //  - flash loan fees: charged on all flash loans, as a percentage of the amounts lent.
    //
    //  - swap fees: a percentage of the fees charged by Pools when performing swaps. For a number of reasons, including
    // swap gas costs and interface simplicity, protocol swap fees are not charged on each individual swap. Rather,
    // Pools are expected to keep track of how much they have charged in swap fees, and pay any outstanding debts to the
    // Vault when they are joined or exited. This prevents users from joining a Pool with unpaid debt, as well as
    // exiting a Pool in debt without first paying their share.

    /**
     * @dev Returns the current protocol fee module.
     */
    function getProtocolFeesCollector() external view returns (ProtocolFeesCollector);

    /**
     * @dev Safety mechanism to pause most Vault operations in the event of an emergency - typically detection of an
     * error in some part of the system.
     *
     * The Vault can only be paused during an initial time period, after which pausing is forever disabled.
     *
     * While the contract is paused, the following features are disabled:
     * - depositing and transferring internal balance
     * - transferring external balance (using the Vault's allowance)
     * - swaps
     * - joining Pools
     * - Asset Manager interactions
     *
     * Internal Balance can still be withdrawn, and Pools exited.
     */
    function setPaused(bool paused) external;

    /**
     * @dev Returns the Vault's WETH instance.
     */
    function WETH() external view returns (IWETH);
    // solhint-disable-previous-line func-name-mixedcase
}

pragma solidity 0.8.19;

/**
 * @dev Building block for performing access control on external functions.
 *
 * This contract is used via the `authenticate` modifier (or the `_authenticateCaller` function), which can be applied
 * to external functions to only make them callable by authorized accounts.
 *
 * Derived contracts must implement the `_canPerform` function, which holds the actual access control logic.
 */
abstract contract Authentication is IAuthentication {
    bytes32 private immutable _actionIdDisambiguator;

    /**
     * @dev The main purpose of the `actionIdDisambiguator` is to prevent accidental function selector collisions in
     * multi contract systems.
     *
     * There are two main uses for it:
     *  - if the contract is a singleton, any unique identifier can be used to make the associated action identifiers
     *    unique. The contract's own address is a good option.
     *  - if the contract belongs to a family that shares action identifiers for the same functions, an identifier
     *    shared by the entire family (and no other contract) should be used instead.
     */
    constructor(bytes32 actionIdDisambiguator) {
        _actionIdDisambiguator = actionIdDisambiguator;
    }

    /**
     * @dev Reverts unless the caller is allowed to call this function. Should only be applied to external functions.
     */
    modifier authenticate() {
        _authenticateCaller();
        _;
    }

    /**
     * @dev Reverts unless the caller is allowed to call the entry point function.
     */
    function _authenticateCaller() internal view {
        bytes32 actionId = getActionId(msg.sig);
        _require(_canPerform(actionId, msg.sender), Errors.SENDER_NOT_ALLOWED);
    }

    function getActionId(bytes4 selector) public view override returns (bytes32) {
        // Each external function is dynamically assigned an action identifier as the hash of the disambiguator and the
        // function selector. Disambiguation is necessary to avoid potential collisions in the function selectors of
        // multiple contracts.
        return keccak256(abi.encodePacked(_actionIdDisambiguator, selector));
    }

    function _canPerform(bytes32 actionId, address user) internal view virtual returns (bool);
}

pragma solidity 0.8.19;

/**
 * @dev Utility for signing Solidity function calls.
 *
 * This contract relies on the fact that Solidity contracts can be called with extra calldata, and enables
 * meta-transaction schemes by appending an EIP712 signature of the original calldata at the end.
 *
 * Derived contracts must implement the `_typeHash` function to map function selectors to EIP712 structs.
 */
abstract contract SignaturesValidator is ISignaturesValidator, EIP712 {
    // The appended data consists of a deadline, plus the [v,r,s] signature. For simplicity, we use a full 256 bit slot
    // for each of these values, even if 'v' is typically an 8 bit value.
    uint256 internal constant _EXTRA_CALLDATA_LENGTH = 4 * 32;

    // Replay attack prevention for each user.
    mapping(address => uint256) internal _nextNonce;

    constructor(string memory name) EIP712(name, "1") {
        // solhint-disable-previous-line no-empty-blocks
    }

    function getDomainSeparator() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    function getNextNonce(address user) external view override returns (uint256) {
        return _nextNonce[user];
    }

    /**
     * @dev Reverts with `errorCode` unless a valid signature for `user` was appended to the calldata.
     */
    function _validateSignature(address user, uint256 errorCode) internal {
        uint256 nextNonce = _nextNonce[user]++;
        _require(_isSignatureValid(user, nextNonce), errorCode);
    }

    function _isSignatureValid(address user, uint256 nonce) private view returns (bool) {
        uint256 deadline = _deadline();

        // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy.
        // solhint-disable-next-line not-rely-on-time
        if (deadline < block.timestamp) {
            return false;
        }

        bytes32 typeHash = _typeHash();
        if (typeHash == bytes32(0)) {
            // Prevent accidental signature validation for functions that don't have an associated type hash.
            return false;
        }

        // All type hashes have this format: (bytes calldata, address sender, uint256 nonce, uint256 deadline).
        bytes32 structHash = keccak256(abi.encode(typeHash, keccak256(_calldata()), msg.sender, nonce, deadline));
        bytes32 digest = _hashTypedDataV4(structHash);
        (uint8 v, bytes32 r, bytes32 s) = _signature();

        address recoveredAddress = ecrecover(digest, v, r, s);

        // ecrecover returns the zero address on recover failure, so we need to handle that explicitly.
        return recoveredAddress != address(0) && recoveredAddress == user;
    }

    /**
     * @dev Returns the EIP712 type hash for the current entry point function, which can be identified by its function
     * selector (available as `msg.sig`).
     *
     * The type hash must conform to the following format:
     *  <name>(bytes calldata, address sender, uint256 nonce, uint256 deadline)
     *
     * If 0x00, all signatures will be considered invalid.
     */
    function _typeHash() internal view virtual returns (bytes32);

    /**
     * @dev Extracts the signature deadline from extra calldata.
     *
     * This function returns bogus data if no signature is included.
     */
    function _deadline() internal pure returns (uint256) {
        // The deadline is the first extra argument at the end of the original calldata.
        return uint256(_decodeExtraCalldataWord(0));
    }

    /**
     * @dev Extracts the signature parameters from extra calldata.
     *
     * This function returns bogus data if no signature is included. This is not a security risk, as that data would not
     * be considered a valid signature in the first place.
     */
    function _signature()
        internal
        pure
        returns (
            uint8 v,
            bytes32 r,
            bytes32 s
        )
    {
        // v, r and s are appended after the signature deadline, in that order.
        v = uint8(uint256(_decodeExtraCalldataWord(0x20)));
        r = _decodeExtraCalldataWord(0x40);
        s = _decodeExtraCalldataWord(0x60);
    }

    /**
     * @dev Returns the original calldata, without the extra bytes containing the signature.
     *
     * This function returns bogus data if no signature is included.
     */
    function _calldata() internal pure returns (bytes memory result) {
        result = msg.data; // A calldata to memory assignment results in memory allocation and copy of contents.
        if (result.length > _EXTRA_CALLDATA_LENGTH) {
            // solhint-disable-next-line no-inline-assembly
            assembly {
                // We simply overwrite the array length with the reduced one.
                mstore(result, sub(calldatasize(), _EXTRA_CALLDATA_LENGTH))
            }
        }
    }

    /**
     * @dev Returns a 256 bit word from 'extra' calldata, at some offset from the expected end of the original calldata.
     *
     * This function returns bogus data if no signature is included.
     */
    function _decodeExtraCalldataWord(uint256 offset) private pure returns (bytes32 result) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            result := calldataload(add(sub(calldatasize(), _EXTRA_CALLDATA_LENGTH), offset))
        }
    }
}

pragma solidity 0.8.19;

/**
 * @dev Allows for a contract to be paused during an initial period after deployment, disabling functionality. Can be
 * used as an emergency switch in case a security vulnerability or threat is identified.
 *
 * The contract can only be paused during the Pause Window, a period that starts at deployment. It can also be
 * unpaused and repaused any number of times during this period. This is intended to serve as a safety measure: it lets
 * system managers react quickly to potentially dangerous situations, knowing that this action is reversible if careful
 * analysis later determines there was a false alarm.
 *
 * If the contract is paused when the Pause Window finishes, it will remain in the paused state through an additional
 * Buffer Period, after which it will be automatically unpaused forever. This is to ensure there is always enough time
 * to react to an emergency, even if the threat is discovered shortly before the Pause Window expires.
 *
 * Note that since the contract can only be paused within the Pause Window, unpausing during the Buffer Period is
 * irreversible.
 */
abstract contract TemporarilyPausable is ITemporarilyPausable {
    // The Pause Window and Buffer Period are timestamp-based: they should not be relied upon for sub-minute accuracy.
    // solhint-disable not-rely-on-time

    uint256 private constant _MAX_PAUSE_WINDOW_DURATION = 90 days;
    uint256 private constant _MAX_BUFFER_PERIOD_DURATION = 30 days;

    uint256 private immutable _pauseWindowEndTime;
    uint256 private immutable _bufferPeriodEndTime;

    bool private _paused;

    constructor(uint256 pauseWindowDuration, uint256 bufferPeriodDuration) {
        _require(pauseWindowDuration <= _MAX_PAUSE_WINDOW_DURATION, Errors.MAX_PAUSE_WINDOW_DURATION);
        _require(bufferPeriodDuration <= _MAX_BUFFER_PERIOD_DURATION, Errors.MAX_BUFFER_PERIOD_DURATION);

        uint256 pauseWindowEndTime = block.timestamp + pauseWindowDuration;

        _pauseWindowEndTime = pauseWindowEndTime;
        _bufferPeriodEndTime = pauseWindowEndTime + bufferPeriodDuration;
    }

    /**
     * @dev Reverts if the contract is paused.
     */
    modifier whenNotPaused() {
        _ensureNotPaused();
        _;
    }

    /**
     * @dev Returns the current contract pause status, as well as the end times of the Pause Window and Buffer
     * Period.
     */
    function getPausedState()
        external
        view
        override
        returns (
            bool paused,
            uint256 pauseWindowEndTime,
            uint256 bufferPeriodEndTime
        )
    {
        paused = !_isNotPaused();
        pauseWindowEndTime = _getPauseWindowEndTime();
        bufferPeriodEndTime = _getBufferPeriodEndTime();
    }

    /**
     * @dev Sets the pause state to `paused`. The contract can only be paused until the end of the Pause Window, and
     * unpaused until the end of the Buffer Period.
     *
     * Once the Buffer Period expires, this function reverts unconditionally.
     */
    function _setPaused(bool paused) internal {
        if (paused) {
            _require(block.timestamp < _getPauseWindowEndTime(), Errors.PAUSE_WINDOW_EXPIRED);
        } else {
            _require(block.timestamp < _getBufferPeriodEndTime(), Errors.BUFFER_PERIOD_EXPIRED);
        }

        _paused = paused;
        emit PausedStateChanged(paused);
    }

    /**
     * @dev Reverts if the contract is paused.
     */
    function _ensureNotPaused() internal view {
        _require(_isNotPaused(), Errors.PAUSED);
    }

    /**
     * @dev Returns true if the contract is unpaused.
     *
     * Once the Buffer Period expires, the gas cost of calling this function is reduced dramatically, as storage is no
     * longer accessed.
     */
    function _isNotPaused() internal view returns (bool) {
        // After the Buffer Period, the (inexpensive) timestamp check short-circuits the storage access.
        return block.timestamp > _getBufferPeriodEndTime() || !_paused;
    }

    // These getters lead to reduced bytecode size by inlining the immutable variables in a single place.

    function _getPauseWindowEndTime() private view returns (uint256) {
        return _pauseWindowEndTime;
    }

    function _getBufferPeriodEndTime() private view returns (uint256) {
        return _bufferPeriodEndTime;
    }
}

pragma solidity 0.8.19;

/**
 * @dev Manages access control of Vault permissioned functions by relying on the Authorizer and signature validation.
 *
 * Additionally handles relayer access and approval.
 */
abstract contract VaultAuthorization is
    IVault,
    ReentrancyGuard,
    Authentication,
    SignaturesValidator,
    TemporarilyPausable
{
    // Ideally, we'd store the type hashes as immutable state variables to avoid computing the hash at runtime, but
    // unfortunately immutable variables cannot be used in assembly, so we just keep the precomputed hashes instead.

    // _JOIN_TYPE_HASH = keccak256("JoinPool(bytes calldata,address sender,uint256 nonce,uint256 deadline)");
    bytes32 private constant _JOIN_TYPE_HASH = 0x3f7b71252bd19113ff48c19c6e004a9bcfcca320a0d74d58e85877cbd7dcae58;

    // _EXIT_TYPE_HASH = keccak256("ExitPool(bytes calldata,address sender,uint256 nonce,uint256 deadline)");
    bytes32 private constant _EXIT_TYPE_HASH = 0x8bbc57f66ea936902f50a71ce12b92c43f3c5340bb40c27c4e90ab84eeae3353;

    // _SWAP_TYPE_HASH = keccak256("Swap(bytes calldata,address sender,uint256 nonce,uint256 deadline)");
    bytes32 private constant _SWAP_TYPE_HASH = 0xe192dcbc143b1e244ad73b813fd3c097b832ad260a157340b4e5e5beda067abe;

    // _BATCH_SWAP_TYPE_HASH = keccak256("BatchSwap(bytes calldata,address sender,uint256 nonce,uint256 deadline)");
    bytes32 private constant _BATCH_SWAP_TYPE_HASH = 0x9bfc43a4d98313c6766986ffd7c916c7481566d9f224c6819af0a53388aced3a;

    // _SET_RELAYER_TYPE_HASH =
    //     keccak256("SetRelayerApproval(bytes calldata,address sender,uint256 nonce,uint256 deadline)");
    bytes32
        private constant _SET_RELAYER_TYPE_HASH = 0xa3f865aa351e51cfeb40f5178d1564bb629fe9030b83caf6361d1baaf5b90b5a;

    IAuthorizer private _authorizer;
    mapping(address => mapping(address => bool)) private _approvedRelayers;

    /**
     * @dev Reverts unless `user` is the caller, or the caller is approved by the Authorizer to call this function (that
     * is, it is a relayer for that function), and either:
     *  a) `user` approved the caller as a relayer (via `setRelayerApproval`), or
     *  b) a valid signature from them was appended to the calldata.
     *
     * Should only be applied to external functions.
     */
    modifier authenticateFor(address user) {
        _authenticateFor(user);
        _;
    }

    constructor(IAuthorizer authorizer)
        // The Vault is a singleton, so it simply uses its own address to disambiguate action identifiers.
        Authentication(bytes32(uint256(uint160(address(this)))))
        SignaturesValidator("Balancer V2 Vault")
    {
        _setAuthorizer(authorizer);
    }

    function setAuthorizer(IAuthorizer newAuthorizer) external override nonReentrant authenticate {
        _setAuthorizer(newAuthorizer);
    }

    function _setAuthorizer(IAuthorizer newAuthorizer) private {
        emit AuthorizerChanged(newAuthorizer);
        _authorizer = newAuthorizer;
    }

    function getAuthorizer() external view override returns (IAuthorizer) {
        return _authorizer;
    }

    function setRelayerApproval(
        address sender,
        address relayer,
        bool approved
    ) external override nonReentrant whenNotPaused authenticateFor(sender) {
        _approvedRelayers[sender][relayer] = approved;
        emit RelayerApprovalChanged(relayer, sender, approved);
    }

    function hasApprovedRelayer(address user, address relayer) external view override returns (bool) {
        return _hasApprovedRelayer(user, relayer);
    }

    /**
     * @dev Reverts unless `user` is the caller, or the caller is approved by the Authorizer to call the entry point
     * function (that is, it is a relayer for that function) and either:
     *  a) `user` approved the caller as a relayer (via `setRelayerApproval`), or
     *  b) a valid signature from them was appended to the calldata.
     */
    function _authenticateFor(address user) internal {
        if (msg.sender != user) {
            // In this context, 'permission to call a function' means 'being a relayer for a function'.
            _authenticateCaller();

            // Being a relayer is not sufficient: `user` must have also approved the caller either via
            // `setRelayerApproval`, or by providing a signature appended to the calldata.
            if (!_hasApprovedRelayer(user, msg.sender)) {
                _validateSignature(user, Errors.USER_DOESNT_ALLOW_RELAYER);
            }
        }
    }

    /**
     * @dev Returns true if `user` approved `relayer` to act as a relayer for them.
     */
    function _hasApprovedRelayer(address user, address relayer) internal view returns (bool) {
        return _approvedRelayers[user][relayer];
    }

    function _canPerform(bytes32 actionId, address user) internal view override returns (bool) {
        // Access control is delegated to the Authorizer.
        return _authorizer.canPerform(actionId, user, address(this));
    }

    function _typeHash() internal pure override returns (bytes32 hash) {
        // This is a simple switch-case statement, trivially written in Solidity by chaining else-if statements, but the
        // assembly implementation results in much denser bytecode.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            // The function selector is located at the first 4 bytes of calldata. We copy the first full calldata
            // 256 word, and then perform a logical shift to the right, moving the selector to the least significant
            // 4 bytes.
            let selector := shr(224, calldataload(0))

            // With the selector in the least significant 4 bytes, we can use 4 byte literals with leading zeros,
            // resulting in dense bytecode (PUSH4 opcodes).
            switch selector
                case 0xb95cac28 {
                    hash := _JOIN_TYPE_HASH
                }
                case 0x8bdb3913 {
                    hash := _EXIT_TYPE_HASH
                }
                case 0x52bbbe29 {
                    hash := _SWAP_TYPE_HASH
                }
                case 0x945bcec9 {
                    hash := _BATCH_SWAP_TYPE_HASH
                }
                case 0xfa6e671d {
                    hash := _SET_RELAYER_TYPE_HASH
                }
                default {
                    hash := 0x0000000000000000000000000000000000000000000000000000000000000000
                }
        }
    }
}

pragma solidity 0.8.19;

/**
 * @dev Maintains the Pool ID data structure, implements Pool ID creation and registration, and defines useful modifiers
 * and helper functions for ensuring correct behavior when working with Pools.
 */
abstract contract PoolRegistry is ReentrancyGuard, VaultAuthorization {
    // Each pool is represented by their unique Pool ID. We use `bytes32` for them, for lack of a way to define new
    // types.
    mapping(bytes32 => bool) private _isPoolRegistered;

    // We keep an increasing nonce to make Pool IDs unique. It is interpreted as a `uint80`, but storing it as a
    // `uint256` results in reduced bytecode on reads and writes due to the lack of masking.
    uint256 private _nextPoolNonce;

    /**
     * @dev Reverts unless `poolId` corresponds to a registered Pool.
     */
    modifier withRegisteredPool(bytes32 poolId) {
        _ensureRegisteredPool(poolId);
        _;
    }

    /**
     * @dev Reverts unless `poolId` corresponds to a registered Pool, and the caller is the Pool's contract.
     */
    modifier onlyPool(bytes32 poolId) {
        _ensurePoolIsSender(poolId);
        _;
    }

    /**
     * @dev Reverts unless `poolId` corresponds to a registered Pool.
     */
    function _ensureRegisteredPool(bytes32 poolId) internal view {
        _require(_isPoolRegistered[poolId], Errors.INVALID_POOL_ID);
    }

    /**
     * @dev Reverts unless `poolId` corresponds to a registered Pool, and the caller is the Pool's contract.
     */
    function _ensurePoolIsSender(bytes32 poolId) private view {
        _ensureRegisteredPool(poolId);
        _require(msg.sender == _getPoolAddress(poolId), Errors.CALLER_NOT_POOL);
    }

    function registerPool(PoolSpecialization specialization)
        external
        override
        nonReentrant
        whenNotPaused
        returns (bytes32)
    {
        // Each Pool is assigned a unique ID based on an incrementing nonce. This assumes there will never be more than
        // 2**80 Pools, and the nonce will not overflow.

        bytes32 poolId = _toPoolId(msg.sender, specialization, uint80(_nextPoolNonce));

        _require(!_isPoolRegistered[poolId], Errors.INVALID_POOL_ID); // Should never happen as Pool IDs are unique.
        _isPoolRegistered[poolId] = true;

        _nextPoolNonce += 1;

        // Note that msg.sender is the pool's contract
        emit PoolRegistered(poolId, msg.sender, specialization);
        return poolId;
    }

    function getPool(bytes32 poolId)
        external
        view
        override
        withRegisteredPool(poolId)
        returns (address, PoolSpecialization)
    {
        return (_getPoolAddress(poolId), _getPoolSpecialization(poolId));
    }

    /**
     * @dev Creates a Pool ID.
     *
     * These are deterministically created by packing the Pool's contract address and its specialization setting into
     * the ID. This saves gas by making this data easily retrievable from a Pool ID with no storage accesses.
     *
     * Since a single contract can register multiple Pools, a unique nonce must be provided to ensure Pool IDs are
     * unique.
     *
     * Pool IDs have the following layout:
     * | 20 bytes pool contract address | 2 bytes specialization setting | 10 bytes nonce |
     * MSB                                                                              LSB
     *
     * 2 bytes for the specialization setting is a bit overkill: there only three of them, which means two bits would
     * suffice. However, there's nothing else of interest to store in this extra space.
     */
    function _toPoolId(
        address pool,
        PoolSpecialization specialization,
        uint80 nonce
    ) internal pure returns (bytes32) {
        bytes32 serialized;

        serialized |= bytes32(uint256(nonce));
        serialized |= bytes32(uint256(specialization)) << (10 * 8);
        serialized |= bytes32(uint256(uint160(pool))) << (12 * 8);

        return serialized;
    }

    /**
     * @dev Returns the address of a Pool's contract.
     *
     * Due to how Pool IDs are created, this is done with no storage accesses and costs little gas.
     */
    function _getPoolAddress(bytes32 poolId) internal pure returns (address) {
        // 12 byte logical shift left to remove the nonce and specialization setting. We don't need to mask,
        // since the logical shift already sets the upper bits to zero.
        return address(uint160(uint256(poolId) >> (12 * 8)));
    }

    /**
     * @dev Returns the specialization setting of a Pool.
     *
     * Due to how Pool IDs are created, this is done with no storage accesses and costs little gas.
     */
    function _getPoolSpecialization(bytes32 poolId) internal pure returns (PoolSpecialization specialization) {
        // 10 byte logical shift left to remove the nonce, followed by a 2 byte mask to remove the address.
        uint256 value = uint256(poolId >> (10 * 8)) & (2**(2 * 8) - 1);

        // Casting a value into an enum results in a runtime check that reverts unless the value is within the enum's
        // range. Passing an invalid Pool ID to this function would then result in an obscure revert with no reason
        // string: we instead perform the check ourselves to help in error diagnosis.

        // There are three Pool specialization settings: general, minimal swap info and two tokens, which correspond to
        // values 0, 1 and 2.
        _require(value < 3, Errors.INVALID_POOL_ID);

        // Because we have checked that `value` is within the enum range, we can use assembly to skip the runtime check.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            specialization := value
        }
    }
}


pragma solidity 0.8.19;

abstract contract GeneralPoolsBalance {
    using BalanceAllocation for bytes32;
    using EnumerableMap for EnumerableMap.IERC20ToBytes32Map;

    // Data for Pools with the General specialization setting
    //
    // These Pools use the IGeneralPool interface, which means the Vault must query the balance for *all* of their
    // tokens in every swap. If we kept a mapping of token to balance plus a set (array) of tokens, it'd be very gas
    // intensive to read all token addresses just to then do a lookup on the balance mapping.
    //
    // Instead, we use our customized EnumerableMap, which lets us read the N balances in N+1 storage accesses (one for
    // each token in the Pool), access the index of any 'token in' a single read (required for the IGeneralPool call),
    // and update an entry's value given its index.

    // Map of token -> balance pairs for each Pool with this specialization. Many functions rely on storage pointers to
    // a Pool's EnumerableMap to save gas when computing storage slots.
    mapping(bytes32 => EnumerableMap.IERC20ToBytes32Map) internal _generalPoolsBalances;

    /**
     * @dev Registers a list of tokens in a General Pool.
     *
     * This function assumes `poolId` exists and corresponds to the General specialization setting.
     *
     * Requirements:
     *
     * - `tokens` must not be registered in the Pool
     * - `tokens` must not contain duplicates
     */
    function _registerGeneralPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];

        for (uint256 i = 0; i < tokens.length; ++i) {
            // EnumerableMaps require an explicit initial value when creating a key-value pair: we use zero, the same
            // value that is found in uninitialized storage, which corresponds to an empty balance.
            bool added = poolBalances.set(tokens[i], 0);
            _require(added, Errors.TOKEN_ALREADY_REGISTERED);
        }
    }

    /**
     * @dev Deregisters a list of tokens in a General Pool.
     *
     * This function assumes `poolId` exists and corresponds to the General specialization setting.
     *
     * Requirements:
     *
     * - `tokens` must be registered in the Pool
     * - `tokens` must have zero balance in the Vault
     * - `tokens` must not contain duplicates
     */
    function _deregisterGeneralPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];

        for (uint256 i = 0; i < tokens.length; ++i) {
            IERC20 token = tokens[i];
            bytes32 currentBalance = _getGeneralPoolBalance(poolBalances, token);
            _require(currentBalance.isZero(), Errors.NONZERO_TOKEN_BALANCE);

            // We don't need to check remove's return value, since _getGeneralPoolBalance already checks that the token
            // was registered.
            poolBalances.remove(token);
        }
    }

    /**
     * @dev Sets the balances of a General Pool's tokens to `balances`.
     *
     * WARNING: this assumes `balances` has the same length and order as the Pool's tokens.
     */
    function _setGeneralPoolBalances(bytes32 poolId, bytes32[] memory balances) internal {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];

        for (uint256 i = 0; i < balances.length; ++i) {
            // Since we assume all balances are properly ordered, we can simply use `unchecked_setAt` to avoid one less
            // storage read per token.
            poolBalances.unchecked_setAt(i, balances[i]);
        }
    }

    /**
     * @dev Transforms `amount` of `token`'s balance in a General Pool from cash into managed.
     *
     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is
     * registered for that Pool.
     */
    function _generalPoolCashToManaged(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal {
        _updateGeneralPoolBalance(poolId, token, BalanceAllocation.cashToManaged, amount);
    }

    /**
     * @dev Transforms `amount` of `token`'s balance in a General Pool from managed into cash.
     *
     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is
     * registered for that Pool.
     */
    function _generalPoolManagedToCash(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal {
        _updateGeneralPoolBalance(poolId, token, BalanceAllocation.managedToCash, amount);
    }

    /**
     * @dev Sets `token`'s managed balance in a General Pool to `amount`.
     *
     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is
     * registered for that Pool.
     *
     * Returns the managed balance delta as a result of this call.
     */
    function _setGeneralPoolManagedBalance(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal returns (int256) {
        return _updateGeneralPoolBalance(poolId, token, BalanceAllocation.setManaged, amount);
    }

    /**
     * @dev Sets `token`'s balance in a General Pool to the result of the `mutation` function when called with the
     * current balance and `amount`.
     *
     * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is
     * registered for that Pool.
     *
     * Returns the managed balance delta as a result of this call.
     */
    function _updateGeneralPoolBalance(
        bytes32 poolId,
        IERC20 token,
        function(bytes32, uint256) returns (bytes32) mutation,
        uint256 amount
    ) private returns (int256) {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];
        bytes32 currentBalance = _getGeneralPoolBalance(poolBalances, token);

        bytes32 newBalance = mutation(currentBalance, amount);
        poolBalances.set(token, newBalance);

        return newBalance.managedDelta(currentBalance);
    }

    /**
     * @dev Returns an array with all the tokens and balances in a General Pool. The order may change when tokens are
     * registered or deregistered.
     *
     * This function assumes `poolId` exists and corresponds to the General specialization setting.
     */
    function _getGeneralPoolTokens(bytes32 poolId)
        internal
        view
        returns (IERC20[] memory tokens, bytes32[] memory balances)
    {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];
        tokens = new IERC20[](poolBalances.length());
        balances = new bytes32[](tokens.length);

        for (uint256 i = 0; i < tokens.length; ++i) {
            // Because the iteration is bounded by `tokens.length`, which matches the EnumerableMap's length, we can use
            // `unchecked_at` as we know `i` is a valid token index, saving storage reads.
            (tokens[i], balances[i]) = poolBalances.unchecked_at(i);
        }
    }

    /**
     * @dev Returns the balance of a token in a General Pool.
     *
     * This function assumes `poolId` exists and corresponds to the General specialization setting.
     *
     * Requirements:
     *
     * - `token` must be registered in the Pool
     */
    function _getGeneralPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];
        return _getGeneralPoolBalance(poolBalances, token);
    }

    /**
     * @dev Same as `_getGeneralPoolBalance` but using a Pool's storage pointer, which saves gas in repeated reads and
     * writes.
     */
    function _getGeneralPoolBalance(EnumerableMap.IERC20ToBytes32Map storage poolBalances, IERC20 token)
        private
        view
        returns (bytes32)
    {
        return poolBalances.get(token, Errors.TOKEN_NOT_REGISTERED);
    }

    /**
     * @dev Returns true if `token` is registered in a General Pool.
     *
     * This function assumes `poolId` exists and corresponds to the General specialization setting.
     */
    function _isGeneralPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) {
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId];
        return poolBalances.contains(token);
    }
}

pragma solidity 0.8.19;

abstract contract MinimalSwapInfoPoolsBalance is PoolRegistry {
    using BalanceAllocation for bytes32;
    using EnumerableSet for EnumerableSet.AddressSet;

    // Data for Pools with the Minimal Swap Info specialization setting
    //
    // These Pools use the IMinimalSwapInfoPool interface, and so the Vault must read the balance of the two tokens
    // in the swap. The best solution is to use a mapping from token to balance, which lets us read or write any token's
    // balance in a single storage access.
    //
    // We also keep a set of registered tokens. Because tokens with non-zero balance are by definition registered, in
    // some balance getters we skip checking for token registration if a non-zero balance is found, saving gas by
    // performing a single read instead of two.

    mapping(bytes32 => mapping(IERC20 => bytes32)) internal _minimalSwapInfoPoolsBalances;
    mapping(bytes32 => EnumerableSet.AddressSet) internal _minimalSwapInfoPoolsTokens;

    /**
     * @dev Registers a list of tokens in a Minimal Swap Info Pool.
     *
     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.
     *
     * Requirements:
     *
     * - `tokens` must not be registered in the Pool
     * - `tokens` must not contain duplicates
     */
    function _registerMinimalSwapInfoPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {
        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];

        for (uint256 i = 0; i < tokens.length; ++i) {
            bool added = poolTokens.add(address(tokens[i]));
            _require(added, Errors.TOKEN_ALREADY_REGISTERED);
            // Note that we don't initialize the balance mapping: the default value of zero corresponds to an empty
            // balance.
        }
    }

    /**
     * @dev Deregisters a list of tokens in a Minimal Swap Info Pool.
     *
     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.
     *
     * Requirements:
     *
     * - `tokens` must be registered in the Pool
     * - `tokens` must have zero balance in the Vault
     * - `tokens` must not contain duplicates
     */
    function _deregisterMinimalSwapInfoPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal {
        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];

        for (uint256 i = 0; i < tokens.length; ++i) {
            IERC20 token = tokens[i];
            _require(_minimalSwapInfoPoolsBalances[poolId][token].isZero(), Errors.NONZERO_TOKEN_BALANCE);

            // For consistency with other Pool specialization settings, we explicitly reset the balance (which may have
            // a non-zero last change block).
            delete _minimalSwapInfoPoolsBalances[poolId][token];

            bool removed = poolTokens.remove(address(token));
            _require(removed, Errors.TOKEN_NOT_REGISTERED);
        }
    }

    /**
     * @dev Sets the balances of a Minimal Swap Info Pool's tokens to `balances`.
     *
     * WARNING: this assumes `balances` has the same length and order as the Pool's tokens.
     */
    function _setMinimalSwapInfoPoolBalances(
        bytes32 poolId,
        IERC20[] memory tokens,
        bytes32[] memory balances
    ) internal {
        for (uint256 i = 0; i < tokens.length; ++i) {
            _minimalSwapInfoPoolsBalances[poolId][tokens[i]] = balances[i];
        }
    }

    /**
     * @dev Transforms `amount` of `token`'s balance in a Minimal Swap Info Pool from cash into managed.
     *
     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that
     * `token` is registered for that Pool.
     */
    function _minimalSwapInfoPoolCashToManaged(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal {
        _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.cashToManaged, amount);
    }

    /**
     * @dev Transforms `amount` of `token`'s balance in a Minimal Swap Info Pool from managed into cash.
     *
     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that
     * `token` is registered for that Pool.
     */
    function _minimalSwapInfoPoolManagedToCash(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal {
        _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.managedToCash, amount);
    }

    /**
     * @dev Sets `token`'s managed balance in a Minimal Swap Info Pool to `amount`.
     *
     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that
     * `token` is registered for that Pool.
     *
     * Returns the managed balance delta as a result of this call.
     */
    function _setMinimalSwapInfoPoolManagedBalance(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal returns (int256) {
        return _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.setManaged, amount);
    }

    /**
     * @dev Sets `token`'s balance in a Minimal Swap Info Pool to the result of the `mutation` function when called with
     * the current balance and `amount`.
     *
     * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that
     * `token` is registered for that Pool.
     *
     * Returns the managed balance delta as a result of this call.
     */
    function _updateMinimalSwapInfoPoolBalance(
        bytes32 poolId,
        IERC20 token,
        function(bytes32, uint256) returns (bytes32) mutation,
        uint256 amount
    ) internal returns (int256) {
        bytes32 currentBalance = _getMinimalSwapInfoPoolBalance(poolId, token);

        bytes32 newBalance = mutation(currentBalance, amount);
        _minimalSwapInfoPoolsBalances[poolId][token] = newBalance;

        return newBalance.managedDelta(currentBalance);
    }

    /**
     * @dev Returns an array with all the tokens and balances in a Minimal Swap Info Pool. The order may change when
     * tokens are registered or deregistered.
     *
     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.
     */
    function _getMinimalSwapInfoPoolTokens(bytes32 poolId)
        internal
        view
        returns (IERC20[] memory tokens, bytes32[] memory balances)
    {
        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];
        tokens = new IERC20[](poolTokens.length());
        balances = new bytes32[](tokens.length);

        for (uint256 i = 0; i < tokens.length; ++i) {
            // Because the iteration is bounded by `tokens.length`, which matches the EnumerableSet's length, we can use
            // `unchecked_at` as we know `i` is a valid token index, saving storage reads.
            IERC20 token = IERC20(poolTokens.unchecked_at(i));
            tokens[i] = token;
            balances[i] = _minimalSwapInfoPoolsBalances[poolId][token];
        }
    }

    /**
     * @dev Returns the balance of a token in a Minimal Swap Info Pool.
     *
     * Requirements:
     *
     * - `poolId` must be a Minimal Swap Info Pool
     * - `token` must be registered in the Pool
     */
    function _getMinimalSwapInfoPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) {
        bytes32 balance = _minimalSwapInfoPoolsBalances[poolId][token];

        // A non-zero balance guarantees that the token is registered. If zero, we manually check if the token is
        // registered in the Pool. Token registration implies that the Pool is registered as well, which lets us save
        // gas by not performing the check.
        bool tokenRegistered = balance.isNotZero() || _minimalSwapInfoPoolsTokens[poolId].contains(address(token));

        if (!tokenRegistered) {
            // The token might not be registered because the Pool itself is not registered. We check this to provide a
            // more accurate revert reason.
            _ensureRegisteredPool(poolId);
            _revert(Errors.TOKEN_NOT_REGISTERED);
        }

        return balance;
    }

    /**
     * @dev Returns true if `token` is registered in a Minimal Swap Info Pool.
     *
     * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting.
     */
    function _isMinimalSwapInfoPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) {
        EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId];
        return poolTokens.contains(address(token));
    }
}

pragma solidity 0.8.19;

abstract contract TwoTokenPoolsBalance is PoolRegistry {
    using BalanceAllocation for bytes32;

    // Data for Pools with the Two Token specialization setting
    //
    // These are similar to the Minimal Swap Info Pool case (because the Pool only has two tokens, and therefore there
    // are only two balances to read), but there's a key difference in how data is stored. Keeping a set makes little
    // sense, as it will only ever hold two tokens, so we can just store those two directly.
    //
    // The gas savings associated with using these Pools come from how token balances are stored: cash amounts for token
    // A and token B are packed together, as are managed amounts. Because only cash changes in a swap, there's no need
    // to write to this second storage slot. A single last change block number for both tokens is stored with the packed
    // cash fields.

    struct TwoTokenPoolBalances {
        bytes32 sharedCash;
        bytes32 sharedManaged;
    }

    // We could just keep a mapping from Pool ID to TwoTokenSharedBalances, but there's an issue: we wouldn't know to
    // which tokens those balances correspond. This would mean having to also check which are registered with the Pool.
    //
    // What we do instead to save those storage reads is keep a nested mapping from the token pair hash to the balances
    // struct. The Pool only has two tokens, so only a single entry of this mapping is set (the one that corresponds to
    // that pair's hash).
    //
    // This has the trade-off of making Vault code that interacts with these Pools cumbersome: both balances must be
    // accessed at the same time by using both token addresses, and some logic is needed to determine how the pair hash
    // is computed. We do this by sorting the tokens, calling the token with the lowest numerical address value token A,
    // and the other one token B. In functions where the token arguments could be either A or B, we use X and Y instead.
    //
    // If users query a token pair containing an unregistered token, the Pool will generate a hash for a mapping entry
    // that was not set, and return zero balances. Non-zero balances are only possible if both tokens in the pair
    // are registered with the Pool, which means we don't have to check the TwoTokenPoolTokens struct, and can save
    // storage reads.

    struct TwoTokenPoolTokens {
        IERC20 tokenA;
        IERC20 tokenB;
        mapping(bytes32 => TwoTokenPoolBalances) balances;
    }

    mapping(bytes32 => TwoTokenPoolTokens) private _twoTokenPoolTokens;

    /**
     * @dev Registers tokens in a Two Token Pool.
     *
     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.
     *
     * Requirements:
     *
     * - `tokenX` and `tokenY` must not be the same
     * - The tokens must be ordered: tokenX < tokenY
     */
    function _registerTwoTokenPoolTokens(
        bytes32 poolId,
        IERC20 tokenX,
        IERC20 tokenY
    ) internal {
        // Not technically true since we didn't register yet, but this is consistent with the error messages of other
        // specialization settings.
        _require(tokenX != tokenY, Errors.TOKEN_ALREADY_REGISTERED);

        _require(tokenX < tokenY, Errors.UNSORTED_TOKENS);

        // A Two Token Pool with no registered tokens is identified by having zero addresses for tokens A and B.
        TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId];
        _require(poolTokens.tokenA == IERC20(address(0)) && poolTokens.tokenB == IERC20(address(0)), Errors.TOKENS_ALREADY_SET);

        // Since tokenX < tokenY, tokenX is A and tokenY is B
        poolTokens.tokenA = tokenX;
        poolTokens.tokenB = tokenY;

        // Note that we don't initialize the balance mapping: the default value of zero corresponds to an empty
        // balance.
    }

    /**
     * @dev Deregisters tokens in a Two Token Pool.
     *
     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.
     *
     * Requirements:
     *
     * - `tokenX` and `tokenY` must be registered in the Pool
     * - both tokens must have zero balance in the Vault
     */
    function _deregisterTwoTokenPoolTokens(
        bytes32 poolId,
        IERC20 tokenX,
        IERC20 tokenY
    ) internal {
        (
            bytes32 balanceA,
            bytes32 balanceB,
            TwoTokenPoolBalances storage poolBalances
        ) = _getTwoTokenPoolSharedBalances(poolId, tokenX, tokenY);

        _require(balanceA.isZero() && balanceB.isZero(), Errors.NONZERO_TOKEN_BALANCE);

        delete _twoTokenPoolTokens[poolId];

        // For consistency with other Pool specialization settings, we explicitly reset the packed cash field (which may
        // have a non-zero last change block).
        delete poolBalances.sharedCash;
    }

    /**
     * @dev Sets the cash balances of a Two Token Pool's tokens.
     *
     * WARNING: this assumes `tokenA` and `tokenB` are the Pool's two registered tokens, and are in the correct order.
     */
    function _setTwoTokenPoolCashBalances(
        bytes32 poolId,
        IERC20 tokenA,
        bytes32 balanceA,
        IERC20 tokenB,
        bytes32 balanceB
    ) internal {
        bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB);
        TwoTokenPoolBalances storage poolBalances = _twoTokenPoolTokens[poolId].balances[pairHash];
        poolBalances.sharedCash = BalanceAllocation.toSharedCash(balanceA, balanceB);
    }

    /**
     * @dev Transforms `amount` of `token`'s balance in a Two Token Pool from cash into managed.
     *
     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is
     * registered for that Pool.
     */
    function _twoTokenPoolCashToManaged(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal {
        _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.cashToManaged, amount);
    }

    /**
     * @dev Transforms `amount` of `token`'s balance in a Two Token Pool from managed into cash.
     *
     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is
     * registered for that Pool.
     */
    function _twoTokenPoolManagedToCash(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal {
        _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.managedToCash, amount);
    }

    /**
     * @dev Sets `token`'s managed balance in a Two Token Pool to `amount`.
     *
     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is
     * registered for that Pool.
     *
     * Returns the managed balance delta as a result of this call.
     */
    function _setTwoTokenPoolManagedBalance(
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) internal returns (int256) {
        return _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.setManaged, amount);
    }

    /**
     * @dev Sets `token`'s balance in a Two Token Pool to the result of the `mutation` function when called with
     * the current balance and `amount`.
     *
     * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is
     * registered for that Pool.
     *
     * Returns the managed balance delta as a result of this call.
     */
    function _updateTwoTokenPoolSharedBalance(
        bytes32 poolId,
        IERC20 token,
        function(bytes32, uint256) returns (bytes32) mutation,
        uint256 amount
    ) private returns (int256) {
        (
            TwoTokenPoolBalances storage balances,
            IERC20 tokenA,
            bytes32 balanceA,
            ,
            bytes32 balanceB
        ) = _getTwoTokenPoolBalances(poolId);

        int256 delta;
        if (token == tokenA) {
            bytes32 newBalance = mutation(balanceA, amount);
            delta = newBalance.managedDelta(balanceA);
            balanceA = newBalance;
        } else {
            // token == tokenB
            bytes32 newBalance = mutation(balanceB, amount);
            delta = newBalance.managedDelta(balanceB);
            balanceB = newBalance;
        }

        balances.sharedCash = BalanceAllocation.toSharedCash(balanceA, balanceB);
        balances.sharedManaged = BalanceAllocation.toSharedManaged(balanceA, balanceB);

        return delta;
    }

    /*
     * @dev Returns an array with all the tokens and balances in a Two Token Pool. The order may change when
     * tokens are registered or deregistered.
     *
     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.
     */
    function _getTwoTokenPoolTokens(bytes32 poolId)
        internal
        view
        returns (IERC20[] memory tokens, bytes32[] memory balances)
    {
        (, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB) = _getTwoTokenPoolBalances(poolId);

        // Both tokens will either be zero (if unregistered) or non-zero (if registered), but we keep the full check for
        // clarity.
        if (tokenA == IERC20(address(0)) || tokenB == IERC20(address(0))) {
            return (new IERC20[](0), new bytes32[](0));
        }

        // Note that functions relying on this getter expect tokens to be properly ordered, so we use the (A, B)
        // ordering.

        tokens = new IERC20[](2);
        tokens[0] = tokenA;
        tokens[1] = tokenB;

        balances = new bytes32[](2);
        balances[0] = balanceA;
        balances[1] = balanceB;
    }

    /**
     * @dev Same as `_getTwoTokenPoolTokens`, except it returns the two tokens and balances directly instead of using
     * an array, as well as a storage pointer to the `TwoTokenPoolBalances` struct, which can be used to update it
     * without having to recompute the pair hash and storage slot.
     */
    function _getTwoTokenPoolBalances(bytes32 poolId)
        private
        view
        returns (
            TwoTokenPoolBalances storage poolBalances,
            IERC20 tokenA,
            bytes32 balanceA,
            IERC20 tokenB,
            bytes32 balanceB
        )
    {
        TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId];
        tokenA = poolTokens.tokenA;
        tokenB = poolTokens.tokenB;

        bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB);
        poolBalances = poolTokens.balances[pairHash];

        bytes32 sharedCash = poolBalances.sharedCash;
        bytes32 sharedManaged = poolBalances.sharedManaged;

        balanceA = BalanceAllocation.fromSharedToBalanceA(sharedCash, sharedManaged);
        balanceB = BalanceAllocation.fromSharedToBalanceB(sharedCash, sharedManaged);
    }

    /**
     * @dev Returns the balance of a token in a Two Token Pool.
     *
     * This function assumes `poolId` exists and corresponds to the General specialization setting.
     *
     * This function is convenient but not particularly gas efficient, and should be avoided during gas-sensitive
     * operations, such as swaps. For those, _getTwoTokenPoolSharedBalances provides a more flexible interface.
     *
     * Requirements:
     *
     * - `token` must be registered in the Pool
     */
    function _getTwoTokenPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) {
        // We can't just read the balance of token, because we need to know the full pair in order to compute the pair
        // hash and access the balance mapping. We therefore rely on `_getTwoTokenPoolBalances`.
        (, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB) = _getTwoTokenPoolBalances(poolId);

        if (token == tokenA) {
            return balanceA;
        } else if (token == tokenB) {
            return balanceB;
        } else {
            _revert(Errors.TOKEN_NOT_REGISTERED);
        }
    }

    /**
     * @dev Returns the balance of the two tokens in a Two Token Pool.
     *
     * The returned balances are those of token A and token B, where token A is the lowest of token X and token Y, and
     * token B the other.
     *
     * This function also returns a storage pointer to the TwoTokenPoolBalances struct associated with the token pair,
     * which can be used to update it without having to recompute the pair hash and storage slot.
     *
     * Requirements:
     *
     * - `poolId` must be a Minimal Swap Info Pool
     * - `tokenX` and `tokenY` must be registered in the Pool
     */
    function _getTwoTokenPoolSharedBalances(
        bytes32 poolId,
        IERC20 tokenX,
        IERC20 tokenY
    )
        internal
        view
        returns (
            bytes32 balanceA,
            bytes32 balanceB,
            TwoTokenPoolBalances storage poolBalances
        )
    {
        (IERC20 tokenA, IERC20 tokenB) = _sortTwoTokens(tokenX, tokenY);
        bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB);

        poolBalances = _twoTokenPoolTokens[poolId].balances[pairHash];

        // Because we're reading balances using the pair hash, if either token X or token Y is not registered then
        // *both* balance entries will be zero.
        bytes32 sharedCash = poolBalances.sharedCash;
        bytes32 sharedManaged = poolBalances.sharedManaged;

        // A non-zero balance guarantees that both tokens are registered. If zero, we manually check whether each
        // token is registered in the Pool. Token registration implies that the Pool is registered as well, which
        // lets us save gas by not performing the check.
        bool tokensRegistered = sharedCash.isNotZero() ||
            sharedManaged.isNotZero() ||
            (_isTwoTokenPoolTokenRegistered(poolId, tokenA) && _isTwoTokenPoolTokenRegistered(poolId, tokenB));

        if (!tokensRegistered) {
            // The tokens might not be registered because the Pool itself is not registered. We check this to provide a
            // more accurate revert reason.
            _ensureRegisteredPool(poolId);
            _revert(Errors.TOKEN_NOT_REGISTERED);
        }

        balanceA = BalanceAllocation.fromSharedToBalanceA(sharedCash, sharedManaged);
        balanceB = BalanceAllocation.fromSharedToBalanceB(sharedCash, sharedManaged);
    }

    /**
     * @dev Returns true if `token` is registered in a Two Token Pool.
     *
     * This function assumes `poolId` exists and corresponds to the Two Token specialization setting.
     */
    function _isTwoTokenPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) {
        TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId];

        // The zero address can never be a registered token.
        return (token == poolTokens.tokenA || token == poolTokens.tokenB) && token != IERC20(address(0));
    }

    /**
     * @dev Returns the hash associated with a given token pair.
     */
    function _getTwoTokenPairHash(IERC20 tokenA, IERC20 tokenB) private pure returns (bytes32) {
        return keccak256(abi.encodePacked(tokenA, tokenB));
    }

    /**
     * @dev Sorts two tokens in ascending order, returning them as a (tokenA, tokenB) tuple.
     */
    function _sortTwoTokens(IERC20 tokenX, IERC20 tokenY) private pure returns (IERC20, IERC20) {
        return tokenX < tokenY ? (tokenX, tokenY) : (tokenY, tokenX);
    }
}

pragma solidity 0.8.19;

abstract contract AssetManagers is
    ReentrancyGuard,
    GeneralPoolsBalance,
    MinimalSwapInfoPoolsBalance,
    TwoTokenPoolsBalance
{
    using Math for uint256;
    using SafeERC20 for IERC20;

    // Stores the Asset Manager for each token of each Pool.
    mapping(bytes32 => mapping(IERC20 => address)) internal _poolAssetManagers;

    function managePoolBalance(PoolBalanceOp[] memory ops) external override nonReentrant whenNotPaused {
        // This variable could be declared inside the loop, but that causes the compiler to allocate memory on each
        // loop iteration, increasing gas costs.
        PoolBalanceOp memory op;

        for (uint256 i = 0; i < ops.length; ++i) {
            // By indexing the array only once, we don't spend extra gas in the same bounds check.
            op = ops[i];

            bytes32 poolId = op.poolId;
            _ensureRegisteredPool(poolId);

            IERC20 token = op.token;
            _require(_isTokenRegistered(poolId, token), Errors.TOKEN_NOT_REGISTERED);
            _require(_poolAssetManagers[poolId][token] == msg.sender, Errors.SENDER_NOT_ASSET_MANAGER);

            PoolBalanceOpKind kind = op.kind;
            uint256 amount = op.amount;
            (int256 cashDelta, int256 managedDelta) = _performPoolManagementOperation(kind, poolId, token, amount);

            emit PoolBalanceManaged(poolId, msg.sender, token, cashDelta, managedDelta);
        }
    }

    /**
     * @dev Performs the `kind` Asset Manager operation on a Pool.
     *
     * Withdrawals will transfer `amount` tokens to the caller, deposits will transfer `amount` tokens from the caller,
     * and updates will set the managed balance to `amount`.
     *
     * Returns a tuple with the 'cash' and 'managed' balance deltas as a result of this call.
     */
    function _performPoolManagementOperation(
        PoolBalanceOpKind kind,
        bytes32 poolId,
        IERC20 token,
        uint256 amount
    ) private returns (int256, int256) {
        PoolSpecialization specialization = _getPoolSpecialization(poolId);

        if (kind == PoolBalanceOpKind.WITHDRAW) {
            return _withdrawPoolBalance(poolId, specialization, token, amount);
        } else if (kind == PoolBalanceOpKind.DEPOSIT) {
            return _depositPoolBalance(poolId, specialization, token, amount);
        } else {
            // PoolBalanceOpKind.UPDATE
            return _updateManagedBalance(poolId, specialization, token, amount);
        }
    }

    /**
     * @dev Moves `amount` tokens from a Pool's 'cash' to 'managed' balance, and transfers them to the caller.
     *
     * Returns the 'cash' and 'managed' balance deltas as a result of this call, which will be complementary.
     */
    function _withdrawPoolBalance(
        bytes32 poolId,
        PoolSpecialization specialization,
        IERC20 token,
        uint256 amount
    ) private returns (int256 cashDelta, int256 managedDelta) {
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            _twoTokenPoolCashToManaged(poolId, token, amount);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            _minimalSwapInfoPoolCashToManaged(poolId, token, amount);
        } else {
            // PoolSpecialization.GENERAL
            _generalPoolCashToManaged(poolId, token, amount);
        }

        if (amount > 0) {
            token.safeTransfer(msg.sender, amount);
        }

        // Since 'cash' and 'managed' are stored as uint112, `amount` is guaranteed to also fit in 112 bits. It will
        // therefore always fit in a 256 bit integer.
        cashDelta = int256(0 - amount);
        managedDelta = int256(amount);
    }

    /**
     * @dev Moves `amount` tokens from a Pool's 'managed' to 'cash' balance, and transfers them from the caller.
     *
     * Returns the 'cash' and 'managed' balance deltas as a result of this call, which will be complementary.
     */
    function _depositPoolBalance(
        bytes32 poolId,
        PoolSpecialization specialization,
        IERC20 token,
        uint256 amount
    ) private returns (int256 cashDelta, int256 managedDelta) {
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            _twoTokenPoolManagedToCash(poolId, token, amount);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            _minimalSwapInfoPoolManagedToCash(poolId, token, amount);
        } else {
            // PoolSpecialization.GENERAL
            _generalPoolManagedToCash(poolId, token, amount);
        }

        if (amount > 0) {
            token.safeTransferFrom(msg.sender, address(this), amount);
        }

        // Since 'cash' and 'managed' are stored as uint112, `amount` is guaranteed to also fit in 112 bits. It will
        // therefore always fit in a 256 bit integer.
        cashDelta = int256(amount);
        managedDelta = int256(0 - amount);
    }

    /**
     * @dev Sets a Pool's 'managed' balance to `amount`.
     *
     * Returns the 'cash' and 'managed' balance deltas as a result of this call (the 'cash' delta will always be zero).
     */
    function _updateManagedBalance(
        bytes32 poolId,
        PoolSpecialization specialization,
        IERC20 token,
        uint256 amount
    ) private returns (int256 cashDelta, int256 managedDelta) {
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            managedDelta = _setTwoTokenPoolManagedBalance(poolId, token, amount);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            managedDelta = _setMinimalSwapInfoPoolManagedBalance(poolId, token, amount);
        } else {
            // PoolSpecialization.GENERAL
            managedDelta = _setGeneralPoolManagedBalance(poolId, token, amount);
        }

        cashDelta = 0;
    }

    /**
     * @dev Returns true if `token` is registered for `poolId`.
     */
    function _isTokenRegistered(bytes32 poolId, IERC20 token) private view returns (bool) {
        PoolSpecialization specialization = _getPoolSpecialization(poolId);
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            return _isTwoTokenPoolTokenRegistered(poolId, token);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            return _isMinimalSwapInfoPoolTokenRegistered(poolId, token);
        } else {
            // PoolSpecialization.GENERAL
            return _isGeneralPoolTokenRegistered(poolId, token);
        }
    }
}

pragma solidity 0.8.19;

abstract contract PoolTokens is ReentrancyGuard, PoolRegistry, AssetManagers {
    using BalanceAllocation for bytes32;
    using BalanceAllocation for bytes32[];

    function registerTokens(
        bytes32 poolId,
        IERC20[] memory tokens,
        address[] memory assetManagers
    ) external override nonReentrant whenNotPaused onlyPool(poolId) {
        InputHelpers.ensureInputLengthMatch(tokens.length, assetManagers.length);

        // Validates token addresses and assigns Asset Managers
        for (uint256 i = 0; i < tokens.length; ++i) {
            IERC20 token = tokens[i];
            _require(token != IERC20(address(0)), Errors.INVALID_TOKEN);

            _poolAssetManagers[poolId][token] = assetManagers[i];
        }

        PoolSpecialization specialization = _getPoolSpecialization(poolId);
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            _require(tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2);
            _registerTwoTokenPoolTokens(poolId, tokens[0], tokens[1]);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            _registerMinimalSwapInfoPoolTokens(poolId, tokens);
        } else {
            // PoolSpecialization.GENERAL
            _registerGeneralPoolTokens(poolId, tokens);
        }

        emit TokensRegistered(poolId, tokens, assetManagers);
    }

    function deregisterTokens(bytes32 poolId, IERC20[] memory tokens)
        external
        override
        nonReentrant
        whenNotPaused
        onlyPool(poolId)
    {
        PoolSpecialization specialization = _getPoolSpecialization(poolId);
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            _require(tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2);
            _deregisterTwoTokenPoolTokens(poolId, tokens[0], tokens[1]);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            _deregisterMinimalSwapInfoPoolTokens(poolId, tokens);
        } else {
            // PoolSpecialization.GENERAL
            _deregisterGeneralPoolTokens(poolId, tokens);
        }

        // The deregister calls above ensure the total token balance is zero. Therefore it is now safe to remove any
        // associated Asset Managers, since they hold no Pool balance.
        for (uint256 i = 0; i < tokens.length; ++i) {
            delete _poolAssetManagers[poolId][tokens[i]];
        }

        emit TokensDeregistered(poolId, tokens);
    }

    function getPoolTokens(bytes32 poolId)
        external
        view
        override
        withRegisteredPool(poolId)
        returns (
            IERC20[] memory tokens,
            uint256[] memory balances,
            uint256 lastChangeBlock
        )
    {
        bytes32[] memory rawBalances;
        (tokens, rawBalances) = _getPoolTokens(poolId);
        (balances, lastChangeBlock) = rawBalances.totalsAndLastChangeBlock();
    }

    function getPoolTokenInfo(bytes32 poolId, IERC20 token)
        external
        view
        override
        withRegisteredPool(poolId)
        returns (
            uint256 cash,
            uint256 managed,
            uint256 lastChangeBlock,
            address assetManager
        )
    {
        bytes32 balance;
        PoolSpecialization specialization = _getPoolSpecialization(poolId);

        if (specialization == PoolSpecialization.TWO_TOKEN) {
            balance = _getTwoTokenPoolBalance(poolId, token);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            balance = _getMinimalSwapInfoPoolBalance(poolId, token);
        } else {
            // PoolSpecialization.GENERAL
            balance = _getGeneralPoolBalance(poolId, token);
        }

        cash = balance.cash();
        managed = balance.managed();
        lastChangeBlock = balance.lastChangeBlock();
        assetManager = _poolAssetManagers[poolId][token];
    }

    /**
     * @dev Returns all of `poolId`'s registered tokens, along with their raw balances.
     */
    function _getPoolTokens(bytes32 poolId) internal view returns (IERC20[] memory tokens, bytes32[] memory balances) {
        PoolSpecialization specialization = _getPoolSpecialization(poolId);
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            return _getTwoTokenPoolTokens(poolId);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            return _getMinimalSwapInfoPoolTokens(poolId);
        } else {
            // PoolSpecialization.GENERAL
            return _getGeneralPoolTokens(poolId);
        }
    }
}

pragma solidity 0.8.19;

/* solhint-disable private-vars-leading-underscore */

library FixedPoint {
    uint256 internal constant ONE = 1e18; // 18 decimal places
    uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14)

    // Minimum base for the power function when the exponent is 'free' (larger than ONE).
    uint256 internal constant MIN_POW_BASE_FREE_EXPONENT = 0.7e18;

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        // Fixed Point addition is the same as regular checked addition

        uint256 c = a + b;
        _require(c >= a, Errors.ADD_OVERFLOW);
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        // Fixed Point addition is the same as regular checked addition

        _require(b <= a, Errors.SUB_OVERFLOW);
        uint256 c = a - b;
        return c;
    }

    function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 product = a * b;
        _require(a == 0 || product / a == b, Errors.MUL_OVERFLOW);

        return product / ONE;
    }

    function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 product = a * b;
        _require(a == 0 || product / a == b, Errors.MUL_OVERFLOW);

        if (product == 0) {
            return 0;
        } else {
            // The traditional divUp formula is:
            // divUp(x, y) := (x + y - 1) / y
            // To avoid intermediate overflow in the addition, we distribute the division and get:
            // divUp(x, y) := (x - 1) / y + 1
            // Note that this requires x != 0, which we already tested for.

            return ((product - 1) / ONE) + 1;
        }
    }

    function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
        _require(b != 0, Errors.ZERO_DIVISION);

        if (a == 0) {
            return 0;
        } else {
            uint256 aInflated = a * ONE;
            _require(aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow

            return aInflated / b;
        }
    }

    function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
        _require(b != 0, Errors.ZERO_DIVISION);

        if (a == 0) {
            return 0;
        } else {
            uint256 aInflated = a * ONE;
            _require(aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow

            // The traditional divUp formula is:
            // divUp(x, y) := (x + y - 1) / y
            // To avoid intermediate overflow in the addition, we distribute the division and get:
            // divUp(x, y) := (x - 1) / y + 1
            // Note that this requires x != 0, which we already tested for.

            return ((aInflated - 1) / b) + 1;
        }
    }

    /**
     * @dev Returns x^y, assuming both are fixed point numbers, rounding down. The result is guaranteed to not be above
     * the true value (that is, the error function expected - actual is always positive).
     */
    function powDown(uint256 x, uint256 y) internal pure returns (uint256) {
        uint256 raw = LogExpMath.pow(x, y);
        uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1);

        if (raw < maxError) {
            return 0;
        } else {
            return sub(raw, maxError);
        }
    }

    /**
     * @dev Returns x^y, assuming both are fixed point numbers, rounding up. The result is guaranteed to not be below
     * the true value (that is, the error function expected - actual is always negative).
     */
    function powUp(uint256 x, uint256 y) internal pure returns (uint256) {
        uint256 raw = LogExpMath.pow(x, y);
        uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1);

        return add(raw, maxError);
    }

    /**
     * @dev Returns the complement of a value (1 - x), capped to 0 if x is larger than 1.
     *
     * Useful when computing the complement for values with some level of relative error, as it strips this error and
     * prevents intermediate negative values.
     */
    function complement(uint256 x) internal pure returns (uint256) {
        return (x < ONE) ? (ONE - x) : 0;
    }
}

pragma solidity 0.8.19;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 */
library EnumerableMap {
    // The original OpenZeppelin implementation uses a generic Map type with bytes32 keys: this was replaced with
    // IERC20ToBytes32Map, which uses IERC20 keys natively, resulting in more dense bytecode.

    struct IERC20ToBytes32MapEntry {
        IERC20 _key;
        bytes32 _value;
    }

    struct IERC20ToBytes32Map {
        // Number of entries in the map
        uint256 _length;
        // Storage of map keys and values
        mapping(uint256 => IERC20ToBytes32MapEntry) _entries;
        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping(IERC20 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        IERC20ToBytes32Map storage map,
        IERC20 key,
        bytes32 value
    ) internal returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        // Equivalent to !contains(map, key)
        if (keyIndex == 0) {
            uint256 previousLength = map._length;
            map._entries[previousLength] = IERC20ToBytes32MapEntry({ _key: key, _value: value });
            map._length = previousLength + 1;

            // The entry is stored at previousLength, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = previousLength + 1;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Updates the value for an entry, given its key's index. The key index can be retrieved via
     * {unchecked_indexOf}, and it should be noted that key indices may change when calling {set} or {remove}. O(1).
     *
     * This function performs one less storage read than {set}, but it should only be used when `index` is known to be
     * within bounds.
     */
    function unchecked_setAt(
        IERC20ToBytes32Map storage map,
        uint256 index,
        bytes32 value
    ) internal {
        map._entries[index]._value = value;
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(IERC20ToBytes32Map storage map, IERC20 key) internal returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        // Equivalent to contains(map, key)
        if (keyIndex != 0) {
            // To delete a key-value pair from the _entries pseudo-array in O(1), we swap the entry to delete with the
            // one at the highest index, and then remove this last entry (sometimes called as 'swap and pop').
            // This modifies the order of the pseudo-array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            IERC20ToBytes32MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            delete map._entries[lastIndex];
            map._length = lastIndex;

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(IERC20ToBytes32Map storage map, IERC20 key) internal view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function length(IERC20ToBytes32Map storage map) internal view returns (uint256) {
        return map._length;
    }

    /**
     * @dev Returns the key-value pair stored at position `index` in the map. O(1).
     *
     * Note that there are no guarantees on the ordering of entries inside the
     * array, and it may change when more entries are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(IERC20ToBytes32Map storage map, uint256 index) internal view returns (IERC20, bytes32) {
        _require(map._length > index, Errors.OUT_OF_BOUNDS);
        return unchecked_at(map, index);
    }

    /**
     * @dev Same as {at}, except this doesn't revert if `index` it outside of the map (i.e. if it is equal or larger
     * than {length}). O(1).
     *
     * This function performs one less storage read than {at}, but should only be used when `index` is known to be
     * within bounds.
     */
    function unchecked_at(IERC20ToBytes32Map storage map, uint256 index) internal view returns (IERC20, bytes32) {
        IERC20ToBytes32MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Same as {unchecked_At}, except it only returns the value and not the key (performing one less storage
     * read). O(1).
     */
    function unchecked_valueAt(IERC20ToBytes32Map storage map, uint256 index) internal view returns (bytes32) {
        return map._entries[index]._value;
    }

    /**
     * @dev Returns the value associated with `key`. O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map. Reverts with `errorCode` otherwise.
     */
    function get(
        IERC20ToBytes32Map storage map,
        IERC20 key,
        uint256 errorCode
    ) internal view returns (bytes32) {
        uint256 index = map._indexes[key];
        _require(index > 0, errorCode);
        return unchecked_valueAt(map, index - 1);
    }

    /**
     * @dev Returns the index for `key` **plus one**. Does not revert if the key is not in the map, and returns 0
     * instead.
     */
    function unchecked_indexOf(IERC20ToBytes32Map storage map, IERC20 key) internal view returns (uint256) {
        return map._indexes[key];
    }
}

pragma solidity 0.8.19;

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(address(token), abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(address(token), abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     *
     * WARNING: `token` is assumed to be a contract: calls to EOAs will *not* revert.
     */
    function _callOptionalReturn(address token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.
        (bool success, bytes memory returndata) = token.call(data);

        // If the low-level call didn't succeed we return whatever was returned from it.
        assembly {
            if eq(success, 0) {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }
        }

        // Finally we check the returndata size is either zero or true - note that this check will always pass for EOAs
        _require(returndata.length == 0 || abi.decode(returndata, (bool)), Errors.SAFE_ERC20_CALL_FAILED);
    }
}

pragma solidity 0.8.19;

library InputHelpers {
    function ensureInputLengthMatch(uint256 a, uint256 b) internal pure {
        _require(a == b, Errors.INPUT_LENGTH_MISMATCH);
    }

    function ensureInputLengthMatch(
        uint256 a,
        uint256 b,
        uint256 c
    ) internal pure {
        _require(a == b && b == c, Errors.INPUT_LENGTH_MISMATCH);
    }

    function ensureArrayIsSorted(IAsset[] memory array) internal pure {
        address[] memory addressArray;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            addressArray := array
        }
        ensureArrayIsSorted(addressArray);
    }

    function ensureArrayIsSorted(IERC20[] memory array) internal pure {
        address[] memory addressArray;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            addressArray := array
        }
        ensureArrayIsSorted(addressArray);
    }

    function ensureArrayIsSorted(address[] memory array) internal pure {
        if (array.length < 2) {
            return;
        }

        address previous = array[0];
        for (uint256 i = 1; i < array.length; ++i) {
            address current = array[i];
            _require(previous < current, Errors.UNSORTED_ARRAY);
            previous = current;
        }
    }
}

pragma solidity 0.8.19;

// Inspired by Aave Protocol's IFlashLoanReceiver.

interface IFlashLoanRecipient {
    /**
     * @dev When `flashLoan` is called on the Vault, it invokes the `receiveFlashLoan` hook on the recipient.
     *
     * At the time of the call, the Vault will have transferred `amounts` for `tokens` to the recipient. Before this
     * call returns, the recipient must have transferred `amounts` plus `feeAmounts` for each token back to the
     * Vault, or else the entire flash loan will revert.
     *
     * `userData` is the same value passed in the `IVault.flashLoan` call.
     */
    function receiveFlashLoan(
        IERC20[] memory tokens,
        uint256[] memory amounts,
        uint256[] memory feeAmounts,
        bytes memory userData
    ) external;
}

pragma solidity 0.8.19;

/**
 * @dev Interface for the WETH token contract used internally for wrapping and unwrapping, to support
 * sending and receiving ETH in joins, swaps, and internal balance deposits and withdrawals.
 */
interface IWETH is IERC20 {
    function deposit() external payable;

    function withdraw(uint256 amount) external;
}

pragma solidity 0.8.19;

interface IAuthorizer {
    /**
     * @dev Returns true if `account` can perform the action described by `actionId` in the contract `where`.
     */
    function canPerform(
        bytes32 actionId,
        address account,
        address where
    ) external view returns (bool);
}


pragma solidity 0.8.19;

interface IPoolSwapStructs {
    // This is not really an interface - it just defines common structs used by other interfaces: IGeneralPool and
    // IMinimalSwapInfoPool.
    //
    // This data structure represents a request for a token swap, where `kind` indicates the swap type ('given in' or
    // 'given out') which indicates whether or not the amount sent by the pool is known.
    //
    // The pool receives `tokenIn` and sends `tokenOut`. `amount` is the number of `tokenIn` tokens the pool will take
    // in, or the number of `tokenOut` tokens the Pool will send out, depending on the given swap `kind`.
    //
    // All other fields are not strictly necessary for most swaps, but are provided to support advanced scenarios in
    // some Pools.
    //
    // `poolId` is the ID of the Pool involved in the swap - this is useful for Pool contracts that implement more than
    // one Pool.
    //
    // The meaning of `lastChangeBlock` depends on the Pool specialization:
    //  - Two Token or Minimal Swap Info: the last block in which either `tokenIn` or `tokenOut` changed its total
    //    balance.
    //  - General: the last block in which *any* of the Pool's registered tokens changed its total balance.
    //
    // `from` is the origin address for the funds the Pool receives, and `to` is the destination address
    // where the Pool sends the outgoing tokens.
    //
    // `userData` is extra data provided by the caller - typically a signature from a trusted party.
    struct SwapRequest {
        IVault.SwapKind kind;
        IERC20 tokenIn;
        IERC20 tokenOut;
        uint256 amount;
        // Misc data
        bytes32 poolId;
        uint256 lastChangeBlock;
        address from;
        address to;
        bytes userData;
    }
}

pragma solidity 0.8.19;

/**
 * @dev Interface for adding and removing liquidity that all Pool contracts should implement. Note that this is not
 * the complete Pool contract interface, as it is missing the swap hooks. Pool contracts should also inherit from
 * either IGeneralPool or IMinimalSwapInfoPool
 */
interface IBasePool is IPoolSwapStructs {
    /**
     * @dev Called by the Vault when a user calls `IVault.joinPool` to add liquidity to this Pool. Returns how many of
     * each registered token the user should provide, as well as the amount of protocol fees the Pool owes to the Vault.
     * The Vault will then take tokens from `sender` and add them to the Pool's balances, as well as collect
     * the reported amount in protocol fees, which the pool should calculate based on `protocolSwapFeePercentage`.
     *
     * Protocol fees are reported and charged on join events so that the Pool is free of debt whenever new users join.
     *
     * `sender` is the account performing the join (from which tokens will be withdrawn), and `recipient` is the account
     * designated to receive any benefits (typically pool shares). `currentBalances` contains the total balances
     * for each token the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return.
     *
     * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total
     * balance.
     *
     * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of
     * join (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.)
     *
     * Contracts implementing this function should check that the caller is indeed the Vault before performing any
     * state-changing operations, such as minting pool shares.
     */
    function onJoinPool(
        bytes32 poolId,
        address sender,
        address recipient,
        uint256[] memory balances,
        uint256 lastChangeBlock,
        uint256 protocolSwapFeePercentage,
        bytes memory userData
    ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);

    /**
     * @dev Called by the Vault when a user calls `IVault.exitPool` to remove liquidity from this Pool. Returns how many
     * tokens the Vault should deduct from the Pool's balances, as well as the amount of protocol fees the Pool owes
     * to the Vault. The Vault will then take tokens from the Pool's balances and send them to `recipient`,
     * as well as collect the reported amount in protocol fees, which the Pool should calculate based on
     * `protocolSwapFeePercentage`.
     *
     * Protocol fees are charged on exit events to guarantee that users exiting the Pool have paid their share.
     *
     * `sender` is the account performing the exit (typically the pool shareholder), and `recipient` is the account
     * to which the Vault will send the proceeds. `currentBalances` contains the total token balances for each token
     * the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return.
     *
     * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total
     * balance.
     *
     * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of
     * exit (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.)
     *
     * Contracts implementing this function should check that the caller is indeed the Vault before performing any
     * state-changing operations, such as burning pool shares.
     */
    function onExitPool(
        bytes32 poolId,
        address sender,
        address recipient,
        uint256[] memory balances,
        uint256 lastChangeBlock,
        uint256 protocolSwapFeePercentage,
        bytes memory userData
    ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);
}

pragma solidity 0.8.19;

/**
 * @dev Pool contracts with the MinimalSwapInfo or TwoToken specialization settings should implement this interface.
 *
 * This is called by the Vault when a user calls `IVault.swap` or `IVault.batchSwap` to swap with this Pool.
 * Returns the number of tokens the Pool will grant to the user in a 'given in' swap, or that the user will grant
 * to the pool in a 'given out' swap.
 *
 * This can often be implemented by a `view` function, since many pricing algorithms don't need to track state
 * changes in swaps. However, contracts implementing this in non-view functions should check that the caller is
 * indeed the Vault.
 */
interface IMinimalSwapInfoPool is IBasePool {
    function onSwap(
        SwapRequest memory swapRequest,
        uint256 currentBalanceTokenIn,
        uint256 currentBalanceTokenOut
    ) external returns (uint256 amount);
}

pragma solidity 0.8.19;

/**
 * @dev IPools with the General specialization setting should implement this interface.
 *
 * This is called by the Vault when a user calls `IVault.swap` or `IVault.batchSwap` to swap with this Pool.
 * Returns the number of tokens the Pool will grant to the user in a 'given in' swap, or that the user will
 * grant to the pool in a 'given out' swap.
 *
 * This can often be implemented by a `view` function, since many pricing algorithms don't need to track state
 * changes in swaps. However, contracts implementing this in non-view functions should check that the caller is
 * indeed the Vault.
 */
interface IGeneralPool is IBasePool {
    function onSwap(
        SwapRequest memory swapRequest,
        uint256[] memory balances,
        uint256 indexIn,
        uint256 indexOut
    ) external returns (uint256 amount);
}

pragma solidity 0.8.19;

abstract contract AssetHelpers {
    // solhint-disable-next-line var-name-mixedcase
    IWETH private immutable _weth;

    // Sentinel value used to indicate WETH with wrapping/unwrapping semantics. The zero address is a good choice for
    // multiple reasons: it is cheap to pass as a calldata argument, it is a known invalid token and non-contract, and
    // it is an address Pools cannot register as a token.
    address private constant _ETH = address(0);

    constructor(IWETH weth) {
        _weth = weth;
    }

    // solhint-disable-next-line func-name-mixedcase
    function _WETH() internal view returns (IWETH) {
        return _weth;
    }

    /**
     * @dev Returns true if `asset` is the sentinel value that represents ETH.
     */
    function _isETH(IAsset asset) internal pure returns (bool) {
        return address(asset) == _ETH;
    }

    /**
     * @dev Translates `asset` into an equivalent IERC20 token address. If `asset` represents ETH, it will be translated
     * to the WETH contract.
     */
    function _translateToIERC20(IAsset asset) internal view returns (IERC20) {
        return _isETH(asset) ? _WETH() : _asIERC20(asset);
    }

    /**
     * @dev Same as `_translateToIERC20(IAsset)`, but for an entire array.
     */
    function _translateToIERC20(IAsset[] memory assets) internal view returns (IERC20[] memory) {
        IERC20[] memory tokens = new IERC20[](assets.length);
        for (uint256 i = 0; i < assets.length; ++i) {
            tokens[i] = _translateToIERC20(assets[i]);
        }
        return tokens;
    }

    /**
     * @dev Interprets `asset` as an IERC20 token. This function should only be called on `asset` if `_isETH` previously
     * returned false for it, that is, if `asset` is guaranteed not to be the ETH sentinel value.
     */
    function _asIERC20(IAsset asset) internal pure returns (IERC20) {
        return IERC20(address(asset));
    }
}

pragma solidity 0.8.19;

abstract contract AssetTransfersHandler is AssetHelpers {
    using SafeERC20 for IERC20;
    using Address for address payable;

    /**
     * @dev Receives `amount` of `asset` from `sender`. If `fromInternalBalance` is true, it first withdraws as much
     * as possible from Internal Balance, then transfers any remaining amount.
     *
     * If `asset` is ETH, `fromInternalBalance` must be false (as ETH cannot be held as internal balance), and the funds
     * will be wrapped into WETH.
     *
     * WARNING: this function does not check that the contract caller has actually supplied any ETH - it is up to the
     * caller of this function to check that this is true to prevent the Vault from using its own ETH (though the Vault
     * typically doesn't hold any).
     */
    function _receiveAsset(
        IAsset asset,
        uint256 amount,
        address sender,
        bool fromInternalBalance
    ) internal {
        if (amount == 0) {
            return;
        }

        if (_isETH(asset)) {
            _require(!fromInternalBalance, Errors.INVALID_ETH_INTERNAL_BALANCE);

            // The ETH amount to receive is deposited into the WETH contract, which will in turn mint WETH for
            // the Vault at a 1:1 ratio.

            // A check for this condition is also introduced by the compiler, but this one provides a revert reason.
            // Note we're checking for the Vault's total balance, *not* ETH sent in this transaction.
            _require(address(this).balance >= amount, Errors.INSUFFICIENT_ETH);
            _WETH().deposit{ value: amount }();
        } else {
            IERC20 token = _asIERC20(asset);

            if (fromInternalBalance) {
                // We take as many tokens from Internal Balance as possible: any remaining amounts will be transferred.
                uint256 deductedBalance = _decreaseInternalBalance(sender, token, amount, true);
                // Because `deductedBalance` will be always the lesser of the current internal balance
                // and the amount to decrease, it is safe to perform unchecked arithmetic.
                amount -= deductedBalance;
            }

            if (amount > 0) {
                token.safeTransferFrom(sender, address(this), amount);
            }
        }
    }

    /**
     * @dev Sends `amount` of `asset` to `recipient`. If `toInternalBalance` is true, the asset is deposited as Internal
     * Balance instead of being transferred.
     *
     * If `asset` is ETH, `toInternalBalance` must be false (as ETH cannot be held as internal balance), and the funds
     * are instead sent directly after unwrapping WETH.
     */
    function _sendAsset(
        IAsset asset,
        uint256 amount,
        address payable recipient,
        bool toInternalBalance
    ) internal {
        if (amount == 0) {
            return;
        }

        if (_isETH(asset)) {
            // Sending ETH is not as involved as receiving it: the only special behavior is it cannot be
            // deposited to Internal Balance.
            _require(!toInternalBalance, Errors.INVALID_ETH_INTERNAL_BALANCE);

            // First, the Vault withdraws deposited ETH from the WETH contract, by burning the same amount of WETH
            // from the Vault. This receipt will be handled by the Vault's `receive`.
            _WETH().withdraw(amount);

            // Then, the withdrawn ETH is sent to the recipient.
            recipient.sendValue(amount);
        } else {
            IERC20 token = _asIERC20(asset);
            if (toInternalBalance) {
                _increaseInternalBalance(recipient, token, amount);
            } else {
                token.safeTransfer(recipient, amount);
            }
        }
    }

    /**
     * @dev Returns excess ETH back to the contract caller, assuming `amountUsed` has been spent. Reverts
     * if the caller sent less ETH than `amountUsed`.
     *
     * Because the caller might not know exactly how much ETH a Vault action will require, they may send extra.
     * Note that this excess value is returned *to the contract caller* (msg.sender). If caller and e.g. swap sender are
     * not the same (because the caller is a relayer for the sender), then it is up to the caller to manage this
     * returned ETH.
     */
    function _handleRemainingEth(uint256 amountUsed) internal {
        _require(msg.value >= amountUsed, Errors.INSUFFICIENT_ETH);

        uint256 excess = msg.value - amountUsed;
        if (excess > 0) {
            payable(msg.sender).sendValue(excess);
        }
    }

    /**
     * @dev Enables the Vault to receive ETH. This is required for it to be able to unwrap WETH, which sends ETH to the
     * caller.
     *
     * Any ETH sent to the Vault outside of the WETH unwrapping mechanism would be forever locked inside the Vault, so
     * we prevent that from happening. Other mechanisms used to send ETH to the Vault (such as being the recipient of an
     * ETH swap, Pool exit or withdrawal, contract self-destruction, or receiving the block mining reward) will result
     * in locked funds, but are not otherwise a security or soundness issue. This check only exists as an attempt to
     * prevent user error.
     */
    receive() external payable {
        _require(msg.sender == address(_WETH()), Errors.ETH_TRANSFER);
    }

    // This contract uses virtual internal functions instead of inheriting from the modules that implement them (in
    // this case UserBalance) in order to decouple it from the rest of the system and enable standalone testing by
    // implementing these with mocks.

    function _increaseInternalBalance(
        address account,
        IERC20 token,
        uint256 amount
    ) internal virtual;

    function _decreaseInternalBalance(
        address account,
        IERC20 token,
        uint256 amount,
        bool capped
    ) internal virtual returns (uint256);
}

pragma solidity 0.8.19;

/**
 * Implement User Balance interactions, which combine Internal Balance and using the Vault's ERC20 allowance.
 *
 * Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later
 * transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination
 * when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced
 * gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users.
 *
 * Internal Balance management features batching, which means a single contract call can be used to perform multiple
 * operations of different kinds, with different senders and recipients, at once.
 */
abstract contract UserBalance is ReentrancyGuard, AssetTransfersHandler, VaultAuthorization {
    using Math for uint256;
    using SafeCast for uint256;
    using SafeERC20 for IERC20;

    // Internal Balance for each token, for each account.
    mapping(address => mapping(IERC20 => uint256)) private _internalTokenBalance;

    function getInternalBalance(address user, IERC20[] memory tokens)
        external
        view
        override
        returns (uint256[] memory balances)
    {
        balances = new uint256[](tokens.length);
        for (uint256 i = 0; i < tokens.length; i++) {
            balances[i] = _getInternalBalance(user, tokens[i]);
        }
    }

    function manageUserBalance(UserBalanceOp[] memory ops) external payable override nonReentrant {
        // We need to track how much of the received ETH was used and wrapped into WETH to return any excess.
        uint256 ethWrapped = 0;

        // Cache for these checks so we only perform them once (if at all).
        bool checkedCallerIsRelayer = false;
        bool checkedNotPaused = false;

        for (uint256 i = 0; i < ops.length; i++) {
            UserBalanceOpKind kind;
            IAsset asset;
            uint256 amount;
            address sender;
            address payable recipient;

            // This destructuring by calling `_validateUserBalanceOp` seems odd, but results in reduced bytecode size.
            (kind, asset, amount, sender, recipient, checkedCallerIsRelayer) = _validateUserBalanceOp(
                ops[i],
                checkedCallerIsRelayer
            );

            if (kind == UserBalanceOpKind.WITHDRAW_INTERNAL) {
                // Internal Balance withdrawals can always be performed by an authorized account.
                _withdrawFromInternalBalance(asset, sender, recipient, amount);
            } else {
                // All other operations are blocked if the contract is paused.

                // We cache the result of the pause check and skip it for other operations in this same transaction
                // (if any).
                if (!checkedNotPaused) {
                    _ensureNotPaused();
                    checkedNotPaused = true;
                }

                if (kind == UserBalanceOpKind.DEPOSIT_INTERNAL) {
                    _depositToInternalBalance(asset, sender, recipient, amount);

                    // Keep track of all ETH wrapped into WETH as part of a deposit.
                    if (_isETH(asset)) {
                        ethWrapped = ethWrapped.add(amount);
                    }
                } else {
                    // Transfers don't support ETH.
                    _require(!_isETH(asset), Errors.CANNOT_USE_ETH_SENTINEL);
                    IERC20 token = _asIERC20(asset);

                    if (kind == UserBalanceOpKind.TRANSFER_INTERNAL) {
                        _transferInternalBalance(token, sender, recipient, amount);
                    } else {
                        // TRANSFER_EXTERNAL
                        _transferToExternalBalance(token, sender, recipient, amount);
                    }
                }
            }
        }

        // Handle any remaining ETH.
        _handleRemainingEth(ethWrapped);
    }

    function _depositToInternalBalance(
        IAsset asset,
        address sender,
        address recipient,
        uint256 amount
    ) private {
        _increaseInternalBalance(recipient, _translateToIERC20(asset), amount);
        _receiveAsset(asset, amount, sender, false);
    }

    function _withdrawFromInternalBalance(
        IAsset asset,
        address sender,
        address payable recipient,
        uint256 amount
    ) private {
        // A partial decrease of Internal Balance is disallowed: `sender` must have the full `amount`.
        _decreaseInternalBalance(sender, _translateToIERC20(asset), amount, false);
        _sendAsset(asset, amount, recipient, false);
    }

    function _transferInternalBalance(
        IERC20 token,
        address sender,
        address recipient,
        uint256 amount
    ) private {
        // A partial decrease of Internal Balance is disallowed: `sender` must have the full `amount`.
        _decreaseInternalBalance(sender, token, amount, false);
        _increaseInternalBalance(recipient, token, amount);
    }

    function _transferToExternalBalance(
        IERC20 token,
        address sender,
        address recipient,
        uint256 amount
    ) private {
        if (amount > 0) {
            token.safeTransferFrom(sender, recipient, amount);
            emit ExternalBalanceTransfer(token, sender, recipient, amount);
        }
    }

    /**
     * @dev Increases `account`'s Internal Balance for `token` by `amount`.
     */
    function _increaseInternalBalance(
        address account,
        IERC20 token,
        uint256 amount
    ) internal override {
        uint256 currentBalance = _getInternalBalance(account, token);
        uint256 newBalance = currentBalance.add(amount);
        _setInternalBalance(account, token, newBalance, amount.toInt256());
    }

    /**
     * @dev Decreases `account`'s Internal Balance for `token` by `amount`. If `allowPartial` is true, this function
     * doesn't revert if `account` doesn't have enough balance, and sets it to zero and returns the deducted amount
     * instead.
     */
    function _decreaseInternalBalance(
        address account,
        IERC20 token,
        uint256 amount,
        bool allowPartial
    ) internal override returns (uint256 deducted) {
        uint256 currentBalance = _getInternalBalance(account, token);
        _require(allowPartial || (currentBalance >= amount), Errors.INSUFFICIENT_INTERNAL_BALANCE);

        deducted = Math.min(currentBalance, amount);
        // By construction, `deducted` is lower or equal to `currentBalance`, so we don't need to use checked
        // arithmetic.
        uint256 newBalance = currentBalance - deducted;
        _setInternalBalance(account, token, newBalance, -(deducted.toInt256()));
    }

    /**
     * @dev Sets `account`'s Internal Balance for `token` to `newBalance`.
     *
     * Emits an `InternalBalanceChanged` event. This event includes `delta`, which is the amount the balance increased
     * (if positive) or decreased (if negative). To avoid reading the current balance in order to compute the delta,
     * this function relies on the caller providing it directly.
     */
    function _setInternalBalance(
        address account,
        IERC20 token,
        uint256 newBalance,
        int256 delta
    ) private {
        _internalTokenBalance[account][token] = newBalance;
        emit InternalBalanceChanged(account, token, delta);
    }

    /**
     * @dev Returns `account`'s Internal Balance for `token`.
     */
    function _getInternalBalance(address account, IERC20 token) internal view returns (uint256) {
        return _internalTokenBalance[account][token];
    }

    /**
     * @dev Destructures a User Balance operation, validating that the contract caller is allowed to perform it.
     */
    function _validateUserBalanceOp(UserBalanceOp memory op, bool checkedCallerIsRelayer)
        private
        view
        returns (
            UserBalanceOpKind,
            IAsset,
            uint256,
            address,
            address payable,
            bool
        )
    {
        // The only argument we need to validate is `sender`, which can only be either the contract caller, or a
        // relayer approved by `sender`.
        address sender = op.sender;

        if (sender != msg.sender) {
            // We need to check both that the contract caller is a relayer, and that `sender` approved them.

            // Because the relayer check is global (i.e. independent of `sender`), we cache that result and skip it for
            // other operations in this same transaction (if any).
            if (!checkedCallerIsRelayer) {
                _authenticateCaller();
                checkedCallerIsRelayer = true;
            }

            _require(_hasApprovedRelayer(sender, msg.sender), Errors.USER_DOESNT_ALLOW_RELAYER);
        }

        return (op.kind, op.asset, op.amount, sender, op.recipient, checkedCallerIsRelayer);
    }
}

pragma solidity 0.8.19;

/**
 * @dev To reduce the bytecode size of the Vault, most of the protocol fee logic is not here, but in the
 * ProtocolFeesCollector contract.
 */
abstract contract Fees is IVault {
    using SafeERC20 for IERC20;

    ProtocolFeesCollector private immutable _protocolFeesCollector;

    constructor() {
        _protocolFeesCollector = new ProtocolFeesCollector(IVault(this));
    }

    function getProtocolFeesCollector() public view override returns (ProtocolFeesCollector) {
        return _protocolFeesCollector;
    }

    /**
     * @dev Returns the protocol swap fee percentage.
     */
    function _getProtocolSwapFeePercentage() internal view returns (uint256) {
        return getProtocolFeesCollector().getSwapFeePercentage();
    }

    /**
     * @dev Returns the protocol fee amount to charge for a flash loan of `amount`.
     */
    function _calculateFlashLoanFeeAmount(uint256 amount) internal view returns (uint256) {
        // Fixed point multiplication introduces error: we round up, which means in certain scenarios the charged
        // percentage can be slightly higher than intended.
        uint256 percentage = getProtocolFeesCollector().getFlashLoanFeePercentage();
        return FixedPoint.mulUp(amount, percentage);
    }

    function _payFeeAmount(IERC20 token, uint256 amount) internal {
        if (amount > 0) {
            token.safeTransfer(address(getProtocolFeesCollector()), amount);
        }
    }
}

pragma solidity 0.8.19;

/**
 * @dev Stores the Asset Managers (by Pool and token), and implements the top level Asset Manager and Pool interfaces,
 * such as registering and deregistering tokens, joining and exiting Pools, and informational functions like `getPool`
 * and `getPoolTokens`, delegating to specialization-specific functions as needed.
 *
 * `managePoolBalance` handles all Asset Manager interactions.
 */
abstract contract PoolBalances is Fees, ReentrancyGuard, PoolTokens, UserBalance {
    using Math for uint256;
    using SafeERC20 for IERC20;
    using BalanceAllocation for bytes32;
    using BalanceAllocation for bytes32[];

    function joinPool(
        bytes32 poolId,
        address sender,
        address recipient,
        JoinPoolRequest memory request
    ) external payable override whenNotPaused {
        // This function doesn't have the nonReentrant modifier: it is applied to `_joinOrExit` instead.

        // Note that `recipient` is not actually payable in the context of a join - we cast it because we handle both
        // joins and exits at once.
        _joinOrExit(PoolBalanceChangeKind.JOIN, poolId, sender, payable(recipient), _toPoolBalanceChange(request));
    }

    function exitPool(
        bytes32 poolId,
        address sender,
        address payable recipient,
        ExitPoolRequest memory request
    ) external override {
        // This function doesn't have the nonReentrant modifier: it is applied to `_joinOrExit` instead.
        _joinOrExit(PoolBalanceChangeKind.EXIT, poolId, sender, recipient, _toPoolBalanceChange(request));
    }

    // This has the exact same layout as JoinPoolRequest and ExitPoolRequest, except the `maxAmountsIn` and
    // `minAmountsOut` are called `limits`. Internally we use this struct for both since these two functions are quite
    // similar, but expose the others to callers for clarity.
    struct PoolBalanceChange {
        IAsset[] assets;
        uint256[] limits;
        bytes userData;
        bool useInternalBalance;
    }

    /**
     * @dev Converts a JoinPoolRequest into a PoolBalanceChange, with no runtime cost.
     */
    function _toPoolBalanceChange(JoinPoolRequest memory request)
        private
        pure
        returns (PoolBalanceChange memory change)
    {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            change := request
        }
    }

    /**
     * @dev Converts an ExitPoolRequest into a PoolBalanceChange, with no runtime cost.
     */
    function _toPoolBalanceChange(ExitPoolRequest memory request)
        private
        pure
        returns (PoolBalanceChange memory change)
    {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            change := request
        }
    }

    /**
     * @dev Implements both `joinPool` and `exitPool`, based on `kind`.
     */
    function _joinOrExit(
        PoolBalanceChangeKind kind,
        bytes32 poolId,
        address sender,
        address payable recipient,
        PoolBalanceChange memory change
    ) private nonReentrant withRegisteredPool(poolId) authenticateFor(sender) {
        // This function uses a large number of stack variables (poolId, sender and recipient, balances, amounts, fees,
        // etc.), which leads to 'stack too deep' issues. It relies on private functions with seemingly arbitrary
        // interfaces to work around this limitation.

        InputHelpers.ensureInputLengthMatch(change.assets.length, change.limits.length);

        // We first check that the caller passed the Pool's registered tokens in the correct order, and retrieve the
        // current balance for each.
        IERC20[] memory tokens = _translateToIERC20(change.assets);
        bytes32[] memory balances = _validateTokensAndGetBalances(poolId, tokens);

        // The bulk of the work is done here: the corresponding Pool hook is called, its final balances are computed,
        // assets are transferred, and fees are paid.
        (
            bytes32[] memory finalBalances,
            uint256[] memory amountsInOrOut,
            uint256[] memory paidProtocolSwapFeeAmounts
        ) = _callPoolBalanceChange(kind, poolId, sender, recipient, change, balances);

        // All that remains is storing the new Pool balances.
        PoolSpecialization specialization = _getPoolSpecialization(poolId);
        if (specialization == PoolSpecialization.TWO_TOKEN) {
            _setTwoTokenPoolCashBalances(poolId, tokens[0], finalBalances[0], tokens[1], finalBalances[1]);
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            _setMinimalSwapInfoPoolBalances(poolId, tokens, finalBalances);
        } else {
            // PoolSpecialization.GENERAL
            _setGeneralPoolBalances(poolId, finalBalances);
        }

        bool positive = kind == PoolBalanceChangeKind.JOIN; // Amounts in are positive, out are negative
        emit PoolBalanceChanged(
            poolId,
            sender,
            tokens,
            // We can unsafely cast to int256 because balances are actually stored as uint112
            _unsafeCastToInt256(amountsInOrOut, positive),
            paidProtocolSwapFeeAmounts
        );
    }

    /**
     * @dev Calls the corresponding Pool hook to get the amounts in/out plus protocol fee amounts, and performs the
     * associated token transfers and fee payments, returning the Pool's final balances.
     */
    function _callPoolBalanceChange(
        PoolBalanceChangeKind kind,
        bytes32 poolId,
        address sender,
        address payable recipient,
        PoolBalanceChange memory change,
        bytes32[] memory balances
    )
        private
        returns (
            bytes32[] memory finalBalances,
            uint256[] memory amountsInOrOut,
            uint256[] memory dueProtocolFeeAmounts
        )
    {
        (uint256[] memory totalBalances, uint256 lastChangeBlock) = balances.totalsAndLastChangeBlock();

        IBasePool pool = IBasePool(_getPoolAddress(poolId));
        (amountsInOrOut, dueProtocolFeeAmounts) = kind == PoolBalanceChangeKind.JOIN
            ? pool.onJoinPool(
                poolId,
                sender,
                recipient,
                totalBalances,
                lastChangeBlock,
                _getProtocolSwapFeePercentage(),
                change.userData
            )
            : pool.onExitPool(
                poolId,
                sender,
                recipient,
                totalBalances,
                lastChangeBlock,
                _getProtocolSwapFeePercentage(),
                change.userData
            );

        InputHelpers.ensureInputLengthMatch(balances.length, amountsInOrOut.length, dueProtocolFeeAmounts.length);

        // The Vault ignores the `recipient` in joins and the `sender` in exits: it is up to the Pool to keep track of
        // their participation.
        finalBalances = kind == PoolBalanceChangeKind.JOIN
            ? _processJoinPoolTransfers(sender, change, balances, amountsInOrOut, dueProtocolFeeAmounts)
            : _processExitPoolTransfers(recipient, change, balances, amountsInOrOut, dueProtocolFeeAmounts);
    }

    /**
     * @dev Transfers `amountsIn` from `sender`, checking that they are within their accepted limits, and pays
     * accumulated protocol swap fees.
     *
     * Returns the Pool's final balances, which are the current balances plus `amountsIn` minus accumulated protocol
     * swap fees.
     */
    function _processJoinPoolTransfers(
        address sender,
        PoolBalanceChange memory change,
        bytes32[] memory balances,
        uint256[] memory amountsIn,
        uint256[] memory dueProtocolFeeAmounts
    ) private returns (bytes32[] memory finalBalances) {
        // We need to track how much of the received ETH was used and wrapped into WETH to return any excess.
        uint256 wrappedEth = 0;

        finalBalances = new bytes32[](balances.length);
        for (uint256 i = 0; i < change.assets.length; ++i) {
            uint256 amountIn = amountsIn[i];
            _require(amountIn <= change.limits[i], Errors.JOIN_ABOVE_MAX);

            // Receive assets from the sender - possibly from Internal Balance.
            IAsset asset = change.assets[i];
            _receiveAsset(asset, amountIn, sender, change.useInternalBalance);

            if (_isETH(asset)) {
                wrappedEth = wrappedEth.add(amountIn);
            }

            uint256 feeAmount = dueProtocolFeeAmounts[i];
            _payFeeAmount(_translateToIERC20(asset), feeAmount);

            // Compute the new Pool balances. Note that the fee amount might be larger than `amountIn`,
            // resulting in an overall decrease of the Pool's balance for a token.
            finalBalances[i] = (amountIn >= feeAmount) // This lets us skip checked arithmetic
                ? balances[i].increaseCash(amountIn - feeAmount)
                : balances[i].decreaseCash(feeAmount - amountIn);
        }

        // Handle any used and remaining ETH.
        _handleRemainingEth(wrappedEth);
    }

    /**
     * @dev Transfers `amountsOut` to `recipient`, checking that they are within their accepted limits, and pays
     * accumulated protocol swap fees from the Pool.
     *
     * Returns the Pool's final balances, which are the current `balances` minus `amountsOut` and fees paid
     * (`dueProtocolFeeAmounts`).
     */
    function _processExitPoolTransfers(
        address payable recipient,
        PoolBalanceChange memory change,
        bytes32[] memory balances,
        uint256[] memory amountsOut,
        uint256[] memory dueProtocolFeeAmounts
    ) private returns (bytes32[] memory finalBalances) {
        finalBalances = new bytes32[](balances.length);
        for (uint256 i = 0; i < change.assets.length; ++i) {
            uint256 amountOut = amountsOut[i];
            _require(amountOut >= change.limits[i], Errors.EXIT_BELOW_MIN);

            // Send tokens to the recipient - possibly to Internal Balance
            IAsset asset = change.assets[i];
            _sendAsset(asset, amountOut, recipient, change.useInternalBalance);

            uint256 feeAmount = dueProtocolFeeAmounts[i];
            _payFeeAmount(_translateToIERC20(asset), feeAmount);

            // Compute the new Pool balances. A Pool's token balance always decreases after an exit (potentially by 0).
            finalBalances[i] = balances[i].decreaseCash(amountOut.add(feeAmount));
        }
    }

    /**
     * @dev Returns the total balance for `poolId`'s `expectedTokens`.
     *
     * `expectedTokens` must exactly equal the token array returned by `getPoolTokens`: both arrays must have the same
     * length, elements and order. Additionally, the Pool must have at least one registered token.
     */
    function _validateTokensAndGetBalances(bytes32 poolId, IERC20[] memory expectedTokens)
        private
        view
        returns (bytes32[] memory)
    {
        (IERC20[] memory actualTokens, bytes32[] memory balances) = _getPoolTokens(poolId);
        InputHelpers.ensureInputLengthMatch(actualTokens.length, expectedTokens.length);
        _require(actualTokens.length > 0, Errors.POOL_NO_TOKENS);

        for (uint256 i = 0; i < actualTokens.length; ++i) {
            _require(actualTokens[i] == expectedTokens[i], Errors.TOKENS_MISMATCH);
        }

        return balances;
    }

    /**
     * @dev Casts an array of uint256 to int256, setting the sign of the result according to the `positive` flag,
     * without checking whether the values fit in the signed 256 bit range.
     */
    function _unsafeCastToInt256(uint256[] memory values, bool positive)
        private
        pure
        returns (int256[] memory signedValues)
    {
        signedValues = new int256[](values.length);
        for (uint256 i = 0; i < values.length; i++) {
            signedValues[i] = positive ? int256(values[i]) : -int256(values[i]);
        }
    }
}

pragma solidity 0.8.19;

/**
 * Implements the Vault's high-level swap functionality.
 *
 * Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. They need not trust the Pool
 * contracts to do this: all security checks are made by the Vault.
 *
 * The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence.
 * In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'),
 * and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out').
 * More complex swaps, such as one 'token in' to multiple tokens out can be achieved by batching together
 * individual swaps.
 */
abstract contract Swaps is ReentrancyGuard, PoolBalances {
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableMap for EnumerableMap.IERC20ToBytes32Map;

    using Math for int256;
    using Math for uint256;
    using SafeCast for uint256;
    using BalanceAllocation for bytes32;

    function swap(
        SingleSwap memory singleSwap,
        FundManagement memory funds,
        uint256 limit,
        uint256 deadline
    )
        external
        payable
        override
        nonReentrant
        whenNotPaused
        authenticateFor(funds.sender)
        returns (uint256 amountCalculated)
    {
        // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy.
        // solhint-disable-next-line not-rely-on-time
        _require(block.timestamp <= deadline, Errors.SWAP_DEADLINE);

        // This revert reason is for consistency with `batchSwap`: an equivalent `swap` performed using that function
        // would result in this error.
        _require(singleSwap.amount > 0, Errors.UNKNOWN_AMOUNT_IN_FIRST_SWAP);

        IERC20 tokenIn = _translateToIERC20(singleSwap.assetIn);
        IERC20 tokenOut = _translateToIERC20(singleSwap.assetOut);
        _require(tokenIn != tokenOut, Errors.CANNOT_SWAP_SAME_TOKEN);

        // Initializing each struct field one-by-one uses less gas than setting all at once.
        IPoolSwapStructs.SwapRequest memory poolRequest;
        poolRequest.poolId = singleSwap.poolId;
        poolRequest.kind = singleSwap.kind;
        poolRequest.tokenIn = tokenIn;
        poolRequest.tokenOut = tokenOut;
        poolRequest.amount = singleSwap.amount;
        poolRequest.userData = singleSwap.userData;
        poolRequest.from = funds.sender;
        poolRequest.to = funds.recipient;
        // The lastChangeBlock field is left uninitialized.

        uint256 amountIn;
        uint256 amountOut;

        (amountCalculated, amountIn, amountOut) = _swapWithPool(poolRequest);
        _require(singleSwap.kind == SwapKind.GIVEN_IN ? amountOut >= limit : amountIn <= limit, Errors.SWAP_LIMIT);

        _receiveAsset(singleSwap.assetIn, amountIn, funds.sender, funds.fromInternalBalance);
        _sendAsset(singleSwap.assetOut, amountOut, funds.recipient, funds.toInternalBalance);

        // If the asset in is ETH, then `amountIn` ETH was wrapped into WETH.
        _handleRemainingEth(_isETH(singleSwap.assetIn) ? amountIn : 0);
    }

    function batchSwap(
        SwapKind kind,
        BatchSwapStep[] memory swaps,
        IAsset[] memory assets,
        FundManagement memory funds,
        int256[] memory limits,
        uint256 deadline
    )
        external
        payable
        override
        nonReentrant
        whenNotPaused
        authenticateFor(funds.sender)
        returns (int256[] memory assetDeltas)
    {
        // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy.
        // solhint-disable-next-line not-rely-on-time
        _require(block.timestamp <= deadline, Errors.SWAP_DEADLINE);

        InputHelpers.ensureInputLengthMatch(assets.length, limits.length);

        // Perform the swaps, updating the Pool token balances and computing the net Vault asset deltas.
        assetDeltas = _swapWithPools(swaps, assets, funds, kind);

        // Process asset deltas, by either transferring assets from the sender (for positive deltas) or to the recipient
        // (for negative deltas).
        uint256 wrappedEth = 0;
        for (uint256 i = 0; i < assets.length; ++i) {
            IAsset asset = assets[i];
            int256 delta = assetDeltas[i];
            _require(delta <= limits[i], Errors.SWAP_LIMIT);

            if (delta > 0) {
                uint256 toReceive = uint256(delta);
                _receiveAsset(asset, toReceive, funds.sender, funds.fromInternalBalance);

                if (_isETH(asset)) {
                    wrappedEth = wrappedEth.add(toReceive);
                }
            } else if (delta < 0) {
                uint256 toSend = uint256(-delta);
                _sendAsset(asset, toSend, funds.recipient, funds.toInternalBalance);
            }
        }

        // Handle any used and remaining ETH.
        _handleRemainingEth(wrappedEth);
    }

    // For `_swapWithPools` to handle both 'given in' and 'given out' swaps, it internally tracks the 'given' amount
    // (supplied by the caller), and the 'calculated' amount (returned by the Pool in response to the swap request).

    /**
     * @dev Given the two swap tokens and the swap kind, returns which one is the 'given' token (the token whose
     * amount is supplied by the caller).
     */
    function _tokenGiven(
        SwapKind kind,
        IERC20 tokenIn,
        IERC20 tokenOut
    ) private pure returns (IERC20) {
        return kind == SwapKind.GIVEN_IN ? tokenIn : tokenOut;
    }

    /**
     * @dev Given the two swap tokens and the swap kind, returns which one is the 'calculated' token (the token whose
     * amount is calculated by the Pool).
     */
    function _tokenCalculated(
        SwapKind kind,
        IERC20 tokenIn,
        IERC20 tokenOut
    ) private pure returns (IERC20) {
        return kind == SwapKind.GIVEN_IN ? tokenOut : tokenIn;
    }

    /**
     * @dev Returns an ordered pair (amountIn, amountOut) given the 'given' and 'calculated' amounts, and the swap kind.
     */
    function _getAmounts(
        SwapKind kind,
        uint256 amountGiven,
        uint256 amountCalculated
    ) private pure returns (uint256 amountIn, uint256 amountOut) {
        if (kind == SwapKind.GIVEN_IN) {
            (amountIn, amountOut) = (amountGiven, amountCalculated);
        } else {
            // SwapKind.GIVEN_OUT
            (amountIn, amountOut) = (amountCalculated, amountGiven);
        }
    }

    /**
     * @dev Performs all `swaps`, calling swap hooks on the Pool contracts and updating their balances. Does not cause
     * any transfer of tokens - instead it returns the net Vault token deltas: positive if the Vault should receive
     * tokens, and negative if it should send them.
     */
    function _swapWithPools(
        BatchSwapStep[] memory swaps,
        IAsset[] memory assets,
        FundManagement memory funds,
        SwapKind kind
    ) private returns (int256[] memory assetDeltas) {
        assetDeltas = new int256[](assets.length);

        // These variables could be declared inside the loop, but that causes the compiler to allocate memory on each
        // loop iteration, increasing gas costs.
        BatchSwapStep memory batchSwapStep;
        IPoolSwapStructs.SwapRequest memory poolRequest;

        // These store data about the previous swap here to implement multihop logic across swaps.
        IERC20 previousTokenCalculated;
        uint256 previousAmountCalculated;

        for (uint256 i = 0; i < swaps.length; ++i) {
            batchSwapStep = swaps[i];

            bool withinBounds = batchSwapStep.assetInIndex < assets.length &&
                batchSwapStep.assetOutIndex < assets.length;
            _require(withinBounds, Errors.OUT_OF_BOUNDS);

            IERC20 tokenIn = _translateToIERC20(assets[batchSwapStep.assetInIndex]);
            IERC20 tokenOut = _translateToIERC20(assets[batchSwapStep.assetOutIndex]);
            _require(tokenIn != tokenOut, Errors.CANNOT_SWAP_SAME_TOKEN);

            // Sentinel value for multihop logic
            if (batchSwapStep.amount == 0) {
                // When the amount given is zero, we use the calculated amount for the previous swap, as long as the
                // current swap's given token is the previous calculated token. This makes it possible to swap a
                // given amount of token A for token B, and then use the resulting token B amount to swap for token C.
                _require(i > 0, Errors.UNKNOWN_AMOUNT_IN_FIRST_SWAP);
                bool usingPreviousToken = previousTokenCalculated == _tokenGiven(kind, tokenIn, tokenOut);
                _require(usingPreviousToken, Errors.MALCONSTRUCTED_MULTIHOP_SWAP);
                batchSwapStep.amount = previousAmountCalculated;
            }

            // Initializing each struct field one-by-one uses less gas than setting all at once
            poolRequest.poolId = batchSwapStep.poolId;
            poolRequest.kind = kind;
            poolRequest.tokenIn = tokenIn;
            poolRequest.tokenOut = tokenOut;
            poolRequest.amount = batchSwapStep.amount;
            poolRequest.userData = batchSwapStep.userData;
            poolRequest.from = funds.sender;
            poolRequest.to = funds.recipient;
            // The lastChangeBlock field is left uninitialized

            uint256 amountIn;
            uint256 amountOut;
            (previousAmountCalculated, amountIn, amountOut) = _swapWithPool(poolRequest);

            previousTokenCalculated = _tokenCalculated(kind, tokenIn, tokenOut);

            // Accumulate Vault deltas across swaps
            assetDeltas[batchSwapStep.assetInIndex] = assetDeltas[batchSwapStep.assetInIndex].add(amountIn.toInt256());
            assetDeltas[batchSwapStep.assetOutIndex] = assetDeltas[batchSwapStep.assetOutIndex].sub(
                amountOut.toInt256()
            );
        }
    }

    /**
     * @dev Performs a swap according to the parameters specified in `request`, calling the Pool's contract hook and
     * updating the Pool's balance.
     *
     * Returns the amount of tokens going into or out of the Vault as a result of this swap, depending on the swap kind.
     */
    function _swapWithPool(IPoolSwapStructs.SwapRequest memory request)
        private
        returns (
            uint256 amountCalculated,
            uint256 amountIn,
            uint256 amountOut
        )
    {
        // Get the calculated amount from the Pool and update its balances
        address pool = _getPoolAddress(request.poolId);
        PoolSpecialization specialization = _getPoolSpecialization(request.poolId);

        if (specialization == PoolSpecialization.TWO_TOKEN) {
            amountCalculated = _processTwoTokenPoolSwapRequest(request, IMinimalSwapInfoPool(pool));
        } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) {
            amountCalculated = _processMinimalSwapInfoPoolSwapRequest(request, IMinimalSwapInfoPool(pool));
        } else {
            // PoolSpecialization.GENERAL
            amountCalculated = _processGeneralPoolSwapRequest(request, IGeneralPool(pool));
        }

        (amountIn, amountOut) = _getAmounts(request.kind, request.amount, amountCalculated);
        emit Swap(request.poolId, request.tokenIn, request.tokenOut, amountIn, amountOut);
    }

    function _processTwoTokenPoolSwapRequest(IPoolSwapStructs.SwapRequest memory request, IMinimalSwapInfoPool pool)
        private
        returns (uint256 amountCalculated)
    {
        // For gas efficiency reasons, this function uses low-level knowledge of how Two Token Pool balances are
        // stored internally, instead of using getters and setters for all operations.

        (
            bytes32 tokenABalance,
            bytes32 tokenBBalance,
            TwoTokenPoolBalances storage poolBalances
        ) = _getTwoTokenPoolSharedBalances(request.poolId, request.tokenIn, request.tokenOut);

        // We have the two Pool balances, but we don't know which one is 'token in' or 'token out'.
        bytes32 tokenInBalance;
        bytes32 tokenOutBalance;

        // In Two Token Pools, token A has a smaller address than token B
        if (request.tokenIn < request.tokenOut) {
            // in is A, out is B
            tokenInBalance = tokenABalance;
            tokenOutBalance = tokenBBalance;
        } else {
            // in is B, out is A
            tokenOutBalance = tokenABalance;
            tokenInBalance = tokenBBalance;
        }

        // Perform the swap request and compute the new balances for 'token in' and 'token out' after the swap
        (tokenInBalance, tokenOutBalance, amountCalculated) = _callMinimalSwapInfoPoolOnSwapHook(
            request,
            pool,
            tokenInBalance,
            tokenOutBalance
        );

        // We check the token ordering again to create the new shared cash packed struct
        poolBalances.sharedCash = request.tokenIn < request.tokenOut
            ? BalanceAllocation.toSharedCash(tokenInBalance, tokenOutBalance) // in is A, out is B
            : BalanceAllocation.toSharedCash(tokenOutBalance, tokenInBalance); // in is B, out is A
    }

    function _processMinimalSwapInfoPoolSwapRequest(
        IPoolSwapStructs.SwapRequest memory request,
        IMinimalSwapInfoPool pool
    ) private returns (uint256 amountCalculated) {
        bytes32 tokenInBalance = _getMinimalSwapInfoPoolBalance(request.poolId, request.tokenIn);
        bytes32 tokenOutBalance = _getMinimalSwapInfoPoolBalance(request.poolId, request.tokenOut);

        // Perform the swap request and compute the new balances for 'token in' and 'token out' after the swap
        (tokenInBalance, tokenOutBalance, amountCalculated) = _callMinimalSwapInfoPoolOnSwapHook(
            request,
            pool,
            tokenInBalance,
            tokenOutBalance
        );

        _minimalSwapInfoPoolsBalances[request.poolId][request.tokenIn] = tokenInBalance;
        _minimalSwapInfoPoolsBalances[request.poolId][request.tokenOut] = tokenOutBalance;
    }

    /**
     * @dev Calls the onSwap hook for a Pool that implements IMinimalSwapInfoPool: both Minimal Swap Info and Two Token
     * Pools do this.
     */
    function _callMinimalSwapInfoPoolOnSwapHook(
        IPoolSwapStructs.SwapRequest memory request,
        IMinimalSwapInfoPool pool,
        bytes32 tokenInBalance,
        bytes32 tokenOutBalance
    )
        internal
        returns (
            bytes32 newTokenInBalance,
            bytes32 newTokenOutBalance,
            uint256 amountCalculated
        )
    {
        uint256 tokenInTotal = tokenInBalance.total();
        uint256 tokenOutTotal = tokenOutBalance.total();
        request.lastChangeBlock = Math.max(tokenInBalance.lastChangeBlock(), tokenOutBalance.lastChangeBlock());

        // Perform the swap request callback, and compute the new balances for 'token in' and 'token out' after the swap
        amountCalculated = pool.onSwap(request, tokenInTotal, tokenOutTotal);
        (uint256 amountIn, uint256 amountOut) = _getAmounts(request.kind, request.amount, amountCalculated);

        newTokenInBalance = tokenInBalance.increaseCash(amountIn);
        newTokenOutBalance = tokenOutBalance.decreaseCash(amountOut);
    }

    function _processGeneralPoolSwapRequest(IPoolSwapStructs.SwapRequest memory request, IGeneralPool pool)
        private
        returns (uint256 amountCalculated)
    {
        bytes32 tokenInBalance;
        bytes32 tokenOutBalance;

        // We access both token indexes without checking existence, because we will do it manually immediately after.
        EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[request.poolId];
        uint256 indexIn = poolBalances.unchecked_indexOf(request.tokenIn);
        uint256 indexOut = poolBalances.unchecked_indexOf(request.tokenOut);

        if (indexIn == 0 || indexOut == 0) {
            // The tokens might not be registered because the Pool itself is not registered. We check this to provide a
            // more accurate revert reason.
            _ensureRegisteredPool(request.poolId);
            _revert(Errors.TOKEN_NOT_REGISTERED);
        }

        // EnumerableMap stores indices *plus one* to use the zero index as a sentinel value - because these are valid,
        // we can undo this.
        indexIn -= 1;
        indexOut -= 1;

        uint256 tokenAmount = poolBalances.length();
        uint256[] memory currentBalances = new uint256[](tokenAmount);

        request.lastChangeBlock = 0;
        for (uint256 i = 0; i < tokenAmount; i++) {
            // Because the iteration is bounded by `tokenAmount`, and no tokens are registered or deregistered here, we
            // know `i` is a valid token index and can use `unchecked_valueAt` to save storage reads.
            bytes32 balance = poolBalances.unchecked_valueAt(i);

            currentBalances[i] = balance.total();
            request.lastChangeBlock = Math.max(request.lastChangeBlock, balance.lastChangeBlock());

            if (i == indexIn) {
                tokenInBalance = balance;
            } else if (i == indexOut) {
                tokenOutBalance = balance;
            }
        }

        // Perform the swap request callback and compute the new balances for 'token in' and 'token out' after the swap
        amountCalculated = pool.onSwap(request, currentBalances, indexIn, indexOut);
        (uint256 amountIn, uint256 amountOut) = _getAmounts(request.kind, request.amount, amountCalculated);
        tokenInBalance = tokenInBalance.increaseCash(amountIn);
        tokenOutBalance = tokenOutBalance.decreaseCash(amountOut);

        // Because no tokens were registered or deregistered between now or when we retrieved the indexes for
        // 'token in' and 'token out', we can use `unchecked_setAt` to save storage reads.
        poolBalances.unchecked_setAt(indexIn, tokenInBalance);
        poolBalances.unchecked_setAt(indexOut, tokenOutBalance);
    }

    // This function is not marked as `nonReentrant` because the underlying mechanism relies on reentrancy
    function queryBatchSwap(
        SwapKind kind,
        BatchSwapStep[] memory swaps,
        IAsset[] memory assets,
        FundManagement memory funds
    ) external override returns (int256[] memory) {
        // In order to accurately 'simulate' swaps, this function actually does perform the swaps, including calling the
        // Pool hooks and updating balances in storage. However, once it computes the final Vault Deltas, it
        // reverts unconditionally, returning this array as the revert data.
        //
        // By wrapping this reverting call, we can decode the deltas 'returned' and return them as a normal Solidity
        // function would. The only caveat is the function becomes non-view, but off-chain clients can still call it
        // via eth_call to get the expected result.
        //
        // This technique was inspired by the work from the Gnosis team in the Gnosis Safe contract:
        // https://github.com/gnosis/safe-contracts/blob/v1.2.0/contracts/GnosisSafe.sol#L265
        //
        // Most of this function is implemented using inline assembly, as the actual work it needs to do is not
        // significant, and Solidity is not particularly well-suited to generate this behavior, resulting in a large
        // amount of generated bytecode.

        if (msg.sender != address(this)) {
            // We perform an external call to ourselves, forwarding the same calldata. In this call, the else clause of
            // the preceding if statement will be executed instead.

            // solhint-disable-next-line avoid-low-level-calls
            (bool success, ) = address(this).call(msg.data);

            // solhint-disable-next-line no-inline-assembly
            assembly {
                // This call should always revert to decode the actual asset deltas from the revert reason
                switch success
                    case 0 {
                        // Note we are manually writing the memory slot 0. We can safely overwrite whatever is
                        // stored there as we take full control of the execution and then immediately return.

                        // We copy the first 4 bytes to check if it matches with the expected signature, otherwise
                        // there was another revert reason and we should forward it.
                        returndatacopy(0, 0, 0x04)
                        let error := and(mload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)

                        // If the first 4 bytes don't match with the expected signature, we forward the revert reason.
                        if eq(eq(error, 0xfa61cc1200000000000000000000000000000000000000000000000000000000), 0) {
                            returndatacopy(0, 0, returndatasize())
                            revert(0, returndatasize())
                        }

                        // The returndata contains the signature, followed by the raw memory representation of an array:
                        // length + data. We need to return an ABI-encoded representation of this array.
                        // An ABI-encoded array contains an additional field when compared to its raw memory
                        // representation: an offset to the location of the length. The offset itself is 32 bytes long,
                        // so the smallest value we  can use is 32 for the data to be located immediately after it.
                        mstore(0, 32)

                        // We now copy the raw memory array from returndata into memory. Since the offset takes up 32
                        // bytes, we start copying at address 0x20. We also get rid of the error signature, which takes
                        // the first four bytes of returndata.
                        let size := sub(returndatasize(), 0x04)
                        returndatacopy(0x20, 0x04, size)

                        // We finally return the ABI-encoded array, which has a total length equal to that of the array
                        // (returndata), plus the 32 bytes for the offset.
                        return(0, add(size, 32))
                    }
                    default {
                        // This call should always revert, but we fail nonetheless if that didn't happen
                        invalid()
                    }
            }
        } else {
            int256[] memory deltas = _swapWithPools(swaps, assets, funds, kind);

            // solhint-disable-next-line no-inline-assembly
            assembly {
                // We will return a raw representation of the array in memory, which is composed of a 32 byte length,
                // followed by the 32 byte int256 values. Because revert expects a size in bytes, we multiply the array
                // length (stored at `deltas`) by 32.
                let size := mul(mload(deltas), 32)

                // We send one extra value for the error signature "QueryError(int256[])" which is 0xfa61cc12.
                // We store it in the previous slot to the `deltas` array. We know there will be at least one available
                // slot due to how the memory scratch space works.
                // We can safely overwrite whatever is stored in this slot as we will revert immediately after that.
                mstore(sub(deltas, 0x20), 0x00000000000000000000000000000000000000000000000000000000fa61cc12)
                let start := sub(deltas, 0x04)

                // When copying from `deltas` into returndata, we copy an additional 36 bytes to also return the array's
                // length and the error signature.
                revert(start, add(size, 36))
            }
        }
    }
}

pragma solidity 0.8.19;

/**
 * @dev Handles Flash Loans through the Vault. Calls the `receiveFlashLoan` hook on the flash loan recipient
 * contract, which implements the `IFlashLoanRecipient` interface.
 */
abstract contract FlashLoans is Fees, ReentrancyGuard, TemporarilyPausable {
    using SafeERC20 for IERC20;

    function flashLoan(
        IFlashLoanRecipient recipient,
        IERC20[] memory tokens,
        uint256[] memory amounts,
        bytes memory userData
    ) external override nonReentrant whenNotPaused {
        InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length);

        uint256[] memory feeAmounts = new uint256[](tokens.length);
        uint256[] memory preLoanBalances = new uint256[](tokens.length);

        // Used to ensure `tokens` is sorted in ascending order, which ensures token uniqueness.
        IERC20 previousToken = IERC20(address(0));

        for (uint256 i = 0; i < tokens.length; ++i) {
            IERC20 token = tokens[i];
            uint256 amount = amounts[i];

            _require(token > previousToken, token == IERC20(address(0)) ? Errors.ZERO_TOKEN : Errors.UNSORTED_TOKENS);
            previousToken = token;

            preLoanBalances[i] = token.balanceOf(address(this));
            feeAmounts[i] = _calculateFlashLoanFeeAmount(amount);

            _require(preLoanBalances[i] >= amount, Errors.INSUFFICIENT_FLASH_LOAN_BALANCE);
            token.safeTransfer(address(recipient), amount);
        }

        recipient.receiveFlashLoan(tokens, amounts, feeAmounts, userData);

        for (uint256 i = 0; i < tokens.length; ++i) {
            IERC20 token = tokens[i];
            uint256 preLoanBalance = preLoanBalances[i];

            // Checking for loan repayment first (without accounting for fees) makes for simpler debugging, and results
            // in more accurate revert reasons if the flash loan protocol fee percentage is zero.
            uint256 postLoanBalance = token.balanceOf(address(this));
            _require(postLoanBalance >= preLoanBalance, Errors.INVALID_POST_LOAN_BALANCE);

            // No need for checked arithmetic since we know the loan was fully repaid.
            uint256 receivedFeeAmount = postLoanBalance - preLoanBalance;
            _require(receivedFeeAmount >= feeAmounts[i], Errors.INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT);

            _payFeeAmount(token, receivedFeeAmount);
            emit FlashLoan(recipient, token, amounts[i], receivedFeeAmount);
        }
    }
}

pragma solidity 0.8.19;

/**
 * @dev This an auxiliary contract to the Vault, deployed by it during construction. It offloads some of the tasks the
 * Vault performs to reduce its overall bytecode size.
 *
 * The current values for all protocol fee percentages are stored here, and any tokens charged as protocol fees are
 * sent to this contract, where they may be withdrawn by authorized entities. All authorization tasks are delegated
 * to the Vault's own authorizer.
 */
contract ProtocolFeesCollector is Authentication, ReentrancyGuard {
    using SafeERC20 for IERC20;

    // Absolute maximum fee percentages (1e18 = 100%, 1e16 = 1%).
    uint256 private constant _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE = 50e16; // 50%
    uint256 private constant _MAX_PROTOCOL_FLASH_LOAN_FEE_PERCENTAGE = 1e16; // 1%

    IVault public immutable vault;

    // All fee percentages are 18-decimal fixed point numbers.

    // The swap fee is charged whenever a swap occurs, as a percentage of the fee charged by the Pool. These are not
    // actually charged on each individual swap: the `Vault` relies on the Pools being honest and reporting fees due
    // when users join and exit them.
    uint256 private _swapFeePercentage;

    // The flash loan fee is charged whenever a flash loan occurs, as a percentage of the tokens lent.
    uint256 private _flashLoanFeePercentage;

    event SwapFeePercentageChanged(uint256 newSwapFeePercentage);
    event FlashLoanFeePercentageChanged(uint256 newFlashLoanFeePercentage);

    constructor(IVault _vault)
        // The ProtocolFeesCollector is a singleton, so it simply uses its own address to disambiguate action
        // identifiers.
        Authentication(bytes32(uint256(uint160(address(this)))))
    {
        vault = _vault;
    }

    function withdrawCollectedFees(
        IERC20[] calldata tokens,
        uint256[] calldata amounts,
        address recipient
    ) external nonReentrant authenticate {
        InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length);

        for (uint256 i = 0; i < tokens.length; ++i) {
            IERC20 token = tokens[i];
            uint256 amount = amounts[i];
            token.safeTransfer(recipient, amount);
        }
    }

    function setSwapFeePercentage(uint256 newSwapFeePercentage) external authenticate {
        _require(newSwapFeePercentage <= _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE, Errors.SWAP_FEE_PERCENTAGE_TOO_HIGH);
        _swapFeePercentage = newSwapFeePercentage;
        emit SwapFeePercentageChanged(newSwapFeePercentage);
    }

    function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external authenticate {
        _require(
            newFlashLoanFeePercentage <= _MAX_PROTOCOL_FLASH_LOAN_FEE_PERCENTAGE,
            Errors.FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH
        );
        _flashLoanFeePercentage = newFlashLoanFeePercentage;
        emit FlashLoanFeePercentageChanged(newFlashLoanFeePercentage);
    }

    function getSwapFeePercentage() external view returns (uint256) {
        return _swapFeePercentage;
    }

    function getFlashLoanFeePercentage() external view returns (uint256) {
        return _flashLoanFeePercentage;
    }

    function getCollectedFeeAmounts(IERC20[] memory tokens) external view returns (uint256[] memory feeAmounts) {
        feeAmounts = new uint256[](tokens.length);
        for (uint256 i = 0; i < tokens.length; ++i) {
            feeAmounts[i] = tokens[i].balanceOf(address(this));
        }
    }

    function getAuthorizer() external view returns (IAuthorizer) {
        return _getAuthorizer();
    }

    function _canPerform(bytes32 actionId, address account) internal view override returns (bool) {
        return _getAuthorizer().canPerform(actionId, account, address(this));
    }

    function _getAuthorizer() internal view returns (IAuthorizer) {
        return vault.getAuthorizer();
    }
}

pragma solidity 0.8.19;
pragma experimental ABIEncoderV2;

/**
 * @dev The `Vault` is Balancer V2's core contract. A single instance of it exists for the entire network, and it is the
 * entity used to interact with Pools by Liquidity Providers who join and exit them, Traders who swap, and Asset
 * Managers who withdraw and deposit tokens.
 *
 * The `Vault`'s source code is split among a number of sub-contracts, with the goal of improving readability and making
 * understanding the system easier. Most sub-contracts have been marked as `abstract` to explicitly indicate that only
 * the full `Vault` is meant to be deployed.
 *
 * Roughly speaking, these are the contents of each sub-contract:
 *
 *  - `AssetManagers`: Pool token Asset Manager registry, and Asset Manager interactions.
 *  - `Fees`: set and compute protocol fees.
 *  - `FlashLoans`: flash loan transfers and fees.
 *  - `PoolBalances`: Pool joins and exits.
 *  - `PoolRegistry`: Pool registration, ID management, and basic queries.
 *  - `PoolTokens`: Pool token registration and registration, and balance queries.
 *  - `Swaps`: Pool swaps.
 *  - `UserBalance`: manage user balances (Internal Balance operations and external balance transfers)
 *  - `VaultAuthorization`: access control, relayers and signature validation.
 *
 * Additionally, the different Pool specializations are handled by the `GeneralPoolsBalance`,
 * `MinimalSwapInfoPoolsBalance` and `TwoTokenPoolsBalance` sub-contracts, which in turn make use of the
 * `BalanceAllocation` library.
 *
 * The most important goal of the `Vault` is to make token swaps use as little gas as possible. This is reflected in a
 * multitude of design decisions, from minor things like the format used to store Pool IDs, to major features such as
 * the different Pool specialization settings.
 *
 * Finally, the large number of tasks carried out by the Vault means its bytecode is very large, close to exceeding
 * the contract size limit imposed by EIP 170 (https://eips.ethereum.org/EIPS/eip-170). Manual tuning of the source code
 * was required to improve code generation and bring the bytecode size below this limit. This includes extensive
 * utilization of `internal` functions (particularly inside modifiers), usage of named return arguments, dedicated
 * storage access methods, dynamic revert reason generation, and usage of inline assembly, to name a few.
 */
contract Vault is VaultAuthorization, FlashLoans, Swaps {
    constructor(
        IAuthorizer authorizer,
        IWETH weth,
        uint256 pauseWindowDuration,
        uint256 bufferPeriodDuration
    ) VaultAuthorization(authorizer) AssetHelpers(weth) TemporarilyPausable(pauseWindowDuration, bufferPeriodDuration) {
        // solhint-disable-previous-line no-empty-blocks
    }

    function setPaused(bool paused) external override nonReentrant authenticate {
        _setPaused(paused);
    }

    // solhint-disable-next-line func-name-mixedcase
    function WETH() external view override returns (IWETH) {
        return _WETH();
    }
}

{
  "optimizer": {
    "enabled": true,
    "mode": "3"
  },
  "outputSelection": {
    "*": {
      "*": [
        "abi",
        "metadata"
      ],
      "": [
        "ast"
      ]
    }
  },
  "detectMissingLibraries": false,
  "forceEVMLA": false,
  "enableEraVMExtensions": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IAuthorizer","name":"authorizer","type":"address"},{"internalType":"contract IWETH","name":"weth","type":"address"},{"internalType":"uint256","name":"pauseWindowDuration","type":"uint256"},{"internalType":"uint256","name":"bufferPeriodDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IAuthorizer","name":"newAuthorizer","type":"address"}],"name":"AuthorizerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ExternalBalanceTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IFlashLoanRecipient","name":"recipient","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"feeAmount","type":"uint256"}],"name":"FlashLoan","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"int256","name":"delta","type":"int256"}],"name":"InternalBalanceChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"paused","type":"bool"}],"name":"PausedStateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"liquidityProvider","type":"address"},{"indexed":false,"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"indexed":false,"internalType":"int256[]","name":"deltas","type":"int256[]"},{"indexed":false,"internalType":"uint256[]","name":"protocolFeeAmounts","type":"uint256[]"}],"name":"PoolBalanceChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"assetManager","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"int256","name":"cashDelta","type":"int256"},{"indexed":false,"internalType":"int256","name":"managedDelta","type":"int256"}],"name":"PoolBalanceManaged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolId","type":"bytes32"},{"indexed":true,"internalType":"address","name":"poolAddress","type":"address"},{"indexed":false,"internalType":"enum IVault.PoolSpecialization","name":"specialization","type":"uint8"}],"name":"PoolRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"relayer","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"RelayerApprovalChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolId","type":"bytes32"},{"indexed":true,"internalType":"contract IERC20","name":"tokenIn","type":"address"},{"indexed":true,"internalType":"contract IERC20","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolId","type":"bytes32"},{"indexed":false,"internalType":"contract IERC20[]","name":"tokens","type":"address[]"}],"name":"TokensDeregistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"poolId","type":"bytes32"},{"indexed":false,"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"indexed":false,"internalType":"address[]","name":"assetManagers","type":"address[]"}],"name":"TokensRegistered","type":"event"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum IVault.SwapKind","name":"kind","type":"uint8"},{"components":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"uint256","name":"assetInIndex","type":"uint256"},{"internalType":"uint256","name":"assetOutIndex","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"internalType":"struct IVault.BatchSwapStep[]","name":"swaps","type":"tuple[]"},{"internalType":"contract IAsset[]","name":"assets","type":"address[]"},{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bool","name":"fromInternalBalance","type":"bool"},{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"bool","name":"toInternalBalance","type":"bool"}],"internalType":"struct IVault.FundManagement","name":"funds","type":"tuple"},{"internalType":"int256[]","name":"limits","type":"int256[]"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"batchSwap","outputs":[{"internalType":"int256[]","name":"assetDeltas","type":"int256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"}],"name":"deregisterTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"address payable","name":"recipient","type":"address"},{"components":[{"internalType":"contract IAsset[]","name":"assets","type":"address[]"},{"internalType":"uint256[]","name":"minAmountsOut","type":"uint256[]"},{"internalType":"bytes","name":"userData","type":"bytes"},{"internalType":"bool","name":"toInternalBalance","type":"bool"}],"internalType":"struct IVault.ExitPoolRequest","name":"request","type":"tuple"}],"name":"exitPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IFlashLoanRecipient","name":"recipient","type":"address"},{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"userData","type":"bytes"}],"name":"flashLoan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"getActionId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAuthorizer","outputs":[{"internalType":"contract IAuthorizer","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeparator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"}],"name":"getInternalBalance","outputs":[{"internalType":"uint256[]","name":"balances","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNextNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPausedState","outputs":[{"internalType":"bool","name":"paused","type":"bool"},{"internalType":"uint256","name":"pauseWindowEndTime","type":"uint256"},{"internalType":"uint256","name":"bufferPeriodEndTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"}],"name":"getPool","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"enum IVault.PoolSpecialization","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"getPoolTokenInfo","outputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"managed","type":"uint256"},{"internalType":"uint256","name":"lastChangeBlock","type":"uint256"},{"internalType":"address","name":"assetManager","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"}],"name":"getPoolTokens","outputs":[{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"balances","type":"uint256[]"},{"internalType":"uint256","name":"lastChangeBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getProtocolFeesCollector","outputs":[{"internalType":"contract ProtocolFeesCollector","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"relayer","type":"address"}],"name":"hasApprovedRelayer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"components":[{"internalType":"contract IAsset[]","name":"assets","type":"address[]"},{"internalType":"uint256[]","name":"maxAmountsIn","type":"uint256[]"},{"internalType":"bytes","name":"userData","type":"bytes"},{"internalType":"bool","name":"fromInternalBalance","type":"bool"}],"internalType":"struct IVault.JoinPoolRequest","name":"request","type":"tuple"}],"name":"joinPool","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"enum IVault.PoolBalanceOpKind","name":"kind","type":"uint8"},{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IVault.PoolBalanceOp[]","name":"ops","type":"tuple[]"}],"name":"managePoolBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"enum IVault.UserBalanceOpKind","name":"kind","type":"uint8"},{"internalType":"contract IAsset","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"address payable","name":"recipient","type":"address"}],"internalType":"struct IVault.UserBalanceOp[]","name":"ops","type":"tuple[]"}],"name":"manageUserBalance","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"enum IVault.SwapKind","name":"kind","type":"uint8"},{"components":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"uint256","name":"assetInIndex","type":"uint256"},{"internalType":"uint256","name":"assetOutIndex","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"internalType":"struct IVault.BatchSwapStep[]","name":"swaps","type":"tuple[]"},{"internalType":"contract IAsset[]","name":"assets","type":"address[]"},{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bool","name":"fromInternalBalance","type":"bool"},{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"bool","name":"toInternalBalance","type":"bool"}],"internalType":"struct IVault.FundManagement","name":"funds","type":"tuple"}],"name":"queryBatchSwap","outputs":[{"internalType":"int256[]","name":"","type":"int256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum IVault.PoolSpecialization","name":"specialization","type":"uint8"}],"name":"registerPool","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"contract IERC20[]","name":"tokens","type":"address[]"},{"internalType":"address[]","name":"assetManagers","type":"address[]"}],"name":"registerTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IAuthorizer","name":"newAuthorizer","type":"address"}],"name":"setAuthorizer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"relayer","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setRelayerApproval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"poolId","type":"bytes32"},{"internalType":"enum IVault.SwapKind","name":"kind","type":"uint8"},{"internalType":"contract IAsset","name":"assetIn","type":"address"},{"internalType":"contract IAsset","name":"assetOut","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"userData","type":"bytes"}],"internalType":"struct IVault.SingleSwap","name":"singleSwap","type":"tuple"},{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bool","name":"fromInternalBalance","type":"bool"},{"internalType":"address payable","name":"recipient","type":"address"},{"internalType":"bool","name":"toInternalBalance","type":"bool"}],"internalType":"struct IVault.FundManagement","name":"funds","type":"tuple"},{"internalType":"uint256","name":"limit","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"swap","outputs":[{"internalType":"uint256","name":"amountCalculated","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

9c4d535b000000000000000000000000000000000000000000000000000000000000000001001323043ea6074f4518900d37a1d5bf09bb0b8161b54242eedb8332cac76c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000800000000000000000000000001b2e98fb28092863f5044a8d2d3f1282622e3f910000000000000000000000003439153eb7af838ad19d56e1571fbd09333c2809000000000000000000000000000000000000000000000000000000000076a7000000000000000000000000000000000000000000000000000000000000278d00

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

0000000000000000000000001b2e98fb28092863f5044a8d2d3f1282622e3f910000000000000000000000003439153eb7af838ad19d56e1571fbd09333c2809000000000000000000000000000000000000000000000000000000000076a7000000000000000000000000000000000000000000000000000000000000278d00

-----Decoded View---------------
Arg [0] : authorizer (address): 0x1b2e98Fb28092863f5044a8d2D3F1282622E3f91
Arg [1] : weth (address): 0x3439153EB7AF838Ad19d56E1571FBD09333C2809
Arg [2] : pauseWindowDuration (uint256): 7776000
Arg [3] : bufferPeriodDuration (uint256): 2592000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000001b2e98fb28092863f5044a8d2d3f1282622e3f91
Arg [1] : 0000000000000000000000003439153eb7af838ad19d56e1571fbd09333c2809
Arg [2] : 000000000000000000000000000000000000000000000000000000000076a700
Arg [3] : 0000000000000000000000000000000000000000000000000000000000278d00