Address Details
contract
0x6ea01ea80FeB4313C3329e6e9fcA751CCb2cF323
- Contract Name
- ManagedPoolFactory
- Creator
- 0x71ee4b–f7430e at 0x99ac2a–99783d
- Balance
- 0 CELO ( )
- Locked CELO Balance
- 0.00 CELO
- Voting CELO Balance
- 0.00 CELO
- Pending Unlocked Gold
- 0.00 CELO
- Tokens
-
Fetching tokens...
- Transactions
- 0 Transactions
- Transfers
- 0 Transfers
- Gas Used
- Fetching gas used...
- Last Balance Update
- 18655459
This contract has been verified via Sourcify.
View contract in Sourcify repository
- Contract name:
- ManagedPoolFactory
- Optimization enabled
- true
- Compiler version
- v0.7.6+commit.7338295f
- Optimization runs
- 500
- EVM Version
- istanbul
- Verified at
- 2023-01-16T17:45:35.193348Z
out/ManagedPoolFactory_flat.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.7.0 <0.9.0; /** * @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); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. 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); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // solhint-disable /** * @dev Reverts if `condition` is false, with a revert reason containing `errorCode`. Only codes up to 999 are * supported. * Uses the default 'BAL' prefix for the error code */ function _require(bool condition, uint256 errorCode) pure { if (!condition) _revert(errorCode); } /** * @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, bytes3 prefix ) pure { if (!condition) _revert(errorCode, prefix); } /** * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported. * Uses the default 'BAL' prefix for the error code */ function _revert(uint256 errorCode) pure { _revert(errorCode, 0x42414c); // This is the raw byte representation of "BAL" } /** * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported. */ function _revert(uint256 errorCode, bytes3 prefix) pure { uint256 prefixUint = uint256(uint24(prefix)); // 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. // We first append the '#' character (0x23) to the prefix. In the case of 'BAL', it results in 0x42414c23 ('BAL#') // Then, we 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 formattedPrefix := shl(24, add(0x23, shl(8, prefixUint))) let revertReason := shl(200, add(formattedPrefix, 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; uint256 internal constant INSUFFICIENT_DATA = 105; // 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; uint256 internal constant NOT_TWO_TOKENS = 210; uint256 internal constant DISABLED = 211; // 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; uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312; uint256 internal constant ORACLE_NOT_INITIALIZED = 313; uint256 internal constant ORACLE_QUERY_TOO_OLD = 314; uint256 internal constant ORACLE_INVALID_INDEX = 315; uint256 internal constant ORACLE_BAD_SECS = 316; uint256 internal constant AMP_END_TIME_TOO_CLOSE = 317; uint256 internal constant AMP_ONGOING_UPDATE = 318; uint256 internal constant AMP_RATE_TOO_HIGH = 319; uint256 internal constant AMP_NO_ONGOING_UPDATE = 320; uint256 internal constant STABLE_INVARIANT_DIDNT_CONVERGE = 321; uint256 internal constant STABLE_GET_BALANCE_DIDNT_CONVERGE = 322; uint256 internal constant RELAYER_NOT_CONTRACT = 323; uint256 internal constant BASE_POOL_RELAYER_NOT_CALLED = 324; uint256 internal constant REBALANCING_RELAYER_REENTERED = 325; uint256 internal constant GRADUAL_UPDATE_TIME_TRAVEL = 326; uint256 internal constant SWAPS_DISABLED = 327; uint256 internal constant CALLER_IS_NOT_LBP_OWNER = 328; uint256 internal constant PRICE_RATE_OVERFLOW = 329; uint256 internal constant INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED = 330; uint256 internal constant WEIGHT_CHANGE_TOO_FAST = 331; uint256 internal constant LOWER_GREATER_THAN_UPPER_TARGET = 332; uint256 internal constant UPPER_TARGET_TOO_HIGH = 333; uint256 internal constant UNHANDLED_BY_LINEAR_POOL = 334; uint256 internal constant OUT_OF_TARGET_RANGE = 335; uint256 internal constant UNHANDLED_EXIT_KIND = 336; uint256 internal constant UNAUTHORIZED_EXIT = 337; uint256 internal constant MAX_MANAGEMENT_SWAP_FEE_PERCENTAGE = 338; uint256 internal constant UNHANDLED_BY_MANAGED_POOL = 339; uint256 internal constant UNHANDLED_BY_PHANTOM_POOL = 340; uint256 internal constant TOKEN_DOES_NOT_HAVE_RATE_PROVIDER = 341; uint256 internal constant INVALID_INITIALIZATION = 342; uint256 internal constant OUT_OF_NEW_TARGET_RANGE = 343; uint256 internal constant FEATURE_DISABLED = 344; uint256 internal constant UNINITIALIZED_POOL_CONTROLLER = 345; uint256 internal constant SET_SWAP_FEE_DURING_FEE_CHANGE = 346; uint256 internal constant SET_SWAP_FEE_PENDING_FEE_CHANGE = 347; uint256 internal constant CHANGE_TOKENS_DURING_WEIGHT_CHANGE = 348; uint256 internal constant CHANGE_TOKENS_PENDING_WEIGHT_CHANGE = 349; uint256 internal constant MAX_WEIGHT = 350; uint256 internal constant UNAUTHORIZED_JOIN = 351; uint256 internal constant MAX_MANAGEMENT_AUM_FEE_PERCENTAGE = 352; uint256 internal constant FRACTIONAL_TARGET = 353; uint256 internal constant ADD_OR_REMOVE_BPT = 354; uint256 internal constant INVALID_CIRCUIT_BREAKER_BOUNDS = 355; uint256 internal constant CIRCUIT_BREAKER_TRIPPED = 356; uint256 internal constant MALICIOUS_QUERY_REVERT = 357; uint256 internal constant JOINS_EXITS_DISABLED = 358; // 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; uint256 internal constant CALLER_IS_NOT_OWNER = 426; uint256 internal constant NEW_OWNER_IS_ZERO = 427; uint256 internal constant CODE_DEPLOYMENT_FAILED = 428; uint256 internal constant CALL_TO_NON_CONTRACT = 429; uint256 internal constant LOW_LEVEL_CALL_FAILED = 430; uint256 internal constant NOT_PAUSED = 431; uint256 internal constant ADDRESS_ALREADY_ALLOWLISTED = 432; uint256 internal constant ADDRESS_NOT_ALLOWLISTED = 433; uint256 internal constant ERC20_BURN_EXCEEDS_BALANCE = 434; uint256 internal constant INVALID_OPERATION = 435; uint256 internal constant CODEC_OVERFLOW = 436; uint256 internal constant IN_RECOVERY_MODE = 437; uint256 internal constant NOT_IN_RECOVERY_MODE = 438; uint256 internal constant INDUCED_FAILURE = 439; uint256 internal constant EXPIRED_SIGNATURE = 440; uint256 internal constant MALFORMED_SIGNATURE = 441; uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_UINT64 = 442; uint256 internal constant UNHANDLED_FEE_TYPE = 443; uint256 internal constant BURN_FROM_ZERO = 444; // 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; uint256 internal constant AUM_FEE_PERCENTAGE_TOO_HIGH = 603; // FeeSplitter uint256 internal constant SPLITTER_FEE_PERCENTAGE_TOO_HIGH = 700; // Misc uint256 internal constant UNIMPLEMENTED = 998; uint256 internal constant SHOULD_NOT_HAPPEN = 999; } /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when 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. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot 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 subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, Errors.SUB_OVERFLOW); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, uint256 errorCode ) internal pure returns (uint256) { _require(b <= a, errorCode); uint256 c = a - b; return c; } } /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is IERC20 { using SafeMath for uint256; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. The total supply should only be read using this function * * Can be overridden by derived contracts to store the total supply in a different way (e.g. packed with other * storage values). */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev Sets a new value for the total supply. It should only be set using this function. * * * Can be overridden by derived contracts to store the total supply in a different way (e.g. packed with other * storage values). */ function _setTotalSupply(uint256 value) internal virtual { _totalSupply = value; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(msg.sender, recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(msg.sender, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve( sender, msg.sender, _allowances[sender][msg.sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE) ); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve( msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, Errors.ERC20_DECREASED_ALLOWANCE_BELOW_ZERO) ); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { _require(sender != address(0), Errors.ERC20_TRANSFER_FROM_ZERO_ADDRESS); _require(recipient != address(0), Errors.ERC20_TRANSFER_TO_ZERO_ADDRESS); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, Errors.ERC20_TRANSFER_EXCEEDS_BALANCE); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { _beforeTokenTransfer(address(0), account, amount); _setTotalSupply(totalSupply().add(amount)); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { _require(account != address(0), Errors.ERC20_BURN_FROM_ZERO_ADDRESS); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, Errors.ERC20_BURN_EXCEEDS_BALANCE); _setTotalSupply(totalSupply().sub(amount)); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual { // solhint-disable-previous-line no-empty-blocks } } /** * @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 >> 255 == 0, Errors.SAFE_CAST_VALUE_CANT_FIT_INT256); return int256(value); } /** * @dev Converts an unsigned uint256 into an unsigned uint64. * * Requirements: * * - input must be less than or equal to maxUint64. */ function toUint64(uint256 value) internal pure returns (uint64) { _require(value <= type(uint64).max, Errors.SAFE_CAST_VALUE_CANT_FIT_UINT64); return uint64(value); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma experimental ABIEncoderV2; /** * @dev Source of truth for all Protocol Fee percentages, that is, how much the protocol charges certain actions. Some * of these values may also be retrievable from other places (such as the swap fee percentage), but this is the * preferred source nonetheless. */ interface IProtocolFeePercentagesProvider { // All fee percentages are 18-decimal fixed point numbers, so e.g. 1e18 = 100% and 1e16 = 1%. // Emitted when a new fee type is registered. event ProtocolFeeTypeRegistered(uint256 indexed feeType, string name, uint256 maximumPercentage); // Emitted when the value of a fee type changes. // IMPORTANT: it is possible for a third party to modify the SWAP and FLASH_LOAN fee type values directly in the // ProtocolFeesCollector, which will result in this event not being emitted despite their value changing. Such usage // of the ProtocolFeesCollector is however discouraged: all state-changing interactions with it should originate in // this contract. event ProtocolFeePercentageChanged(uint256 indexed feeType, uint256 percentage); /** * @dev Registers a new fee type in the system, making it queryable via `getFeeTypePercentage` and `getFeeTypeName`, * as well as configurable via `setFeeTypePercentage`. * * `feeType` can be any arbitrary value (that is not in use). * * It is not possible to de-register fee types, nor change their name or maximum value. */ function registerFeeType( uint256 feeType, string memory name, uint256 maximumValue, uint256 initialValue ) external; /** * @dev Returns true if `feeType` has been registered and can be queried. */ function isValidFeeType(uint256 feeType) external view returns (bool); /** * @dev Returns true if `value` is a valid percentage value for `feeType`. */ function isValidFeeTypePercentage(uint256 feeType, uint256 value) external view returns (bool); /** * @dev Sets the percentage value for `feeType` to `newValue`. * * IMPORTANT: it is possible for a third party to modify the SWAP and FLASH_LOAN fee type values directly in the * ProtocolFeesCollector, without invoking this function. This will result in the `ProtocolFeePercentageChanged` * event not being emitted despite their value changing. Such usage of the ProtocolFeesCollector is however * discouraged: only this contract should be granted permission to call `setSwapFeePercentage` and * `setFlashLoanFeePercentage`. */ function setFeeTypePercentage(uint256 feeType, uint256 newValue) external; /** * @dev Returns the current percentage value for `feeType`. This is the preferred mechanism for querying these - * whenever possible, use this fucntion instead of e.g. querying the ProtocolFeesCollector. */ function getFeeTypePercentage(uint256 feeType) external view returns (uint256); /** * @dev Returns `feeType`'s maximum value. */ function getFeeTypeMaximumPercentage(uint256 feeType) external view returns (uint256); /** * @dev Returns `feeType`'s name. */ function getFeeTypeName(uint256 feeType) external view returns (string memory); } library ProtocolFeeType { // This list is not exhaustive - more fee types can be added to the system. It is expected for this list to be // extended with new fee types as they are registered, to keep them all in one place and reduce // likelihood of user error. // solhint-disable private-vars-leading-underscore uint256 internal constant SWAP = 0; uint256 internal constant FLASH_LOAN = 1; uint256 internal constant YIELD = 2; uint256 internal constant AUM = 3; // solhint-enable private-vars-leading-underscore } /** * @dev Wrappers over Solidity's arithmetic operations with added overflow checks. * Adapted from OpenZeppelin's SafeMath library. */ library Math { // solhint-disable no-inline-assembly /** * @dev Returns the absolute value of a signed integer. */ function abs(int256 a) internal pure returns (uint256 result) { // Equivalent to: // result = a > 0 ? uint256(a) : uint256(-a) assembly { let s := sar(255, a) result := sub(xor(a, s), s) } } /** * @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 result) { // Equivalent to: // result = (a < b) ? b : a; assembly { result := sub(a, mul(sub(a, b), lt(a, b))) } } /** * @dev Returns the smallest of two numbers of 256 bits. */ function min(uint256 a, uint256 b) internal pure returns (uint256 result) { // Equivalent to `result = (a < b) ? a : b` assembly { result := sub(a, mul(sub(a, b), gt(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 div( uint256 a, uint256 b, bool roundUp ) internal pure returns (uint256) { return roundUp ? divUp(a, b) : divDown(a, b); } function divDown(uint256 a, uint256 b) internal pure returns (uint256) { _require(b != 0, Errors.ZERO_DIVISION); return a / b; } function divUp(uint256 a, uint256 b) internal pure returns (uint256 result) { _require(b != 0, Errors.ZERO_DIVISION); // Equivalent to: // result = a == 0 ? 0 : 1 + (a - 1) / b; assembly { result := mul(iszero(iszero(a)), add(1, div(sub(a, 1), b))) } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @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 } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @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 ); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. interface IAuthentication { /** * @dev Returns the action identifier associated with the external function described by `selector`. */ function getActionId(bytes4 selector) external view returns (bytes32); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library WeightedPoolUserData { // In order to preserve backwards compatibility, make sure new join and exit kinds are added at the end of the enum. enum JoinKind { INIT, EXACT_TOKENS_IN_FOR_BPT_OUT, TOKEN_IN_FOR_EXACT_BPT_OUT, ALL_TOKENS_IN_FOR_EXACT_BPT_OUT } enum ExitKind { EXACT_BPT_IN_FOR_ONE_TOKEN_OUT, EXACT_BPT_IN_FOR_TOKENS_OUT, BPT_IN_FOR_EXACT_TOKENS_OUT } function joinKind(bytes memory self) internal pure returns (JoinKind) { return abi.decode(self, (JoinKind)); } function exitKind(bytes memory self) internal pure returns (ExitKind) { return abi.decode(self, (ExitKind)); } // Joins function initialAmountsIn(bytes memory self) internal pure returns (uint256[] memory amountsIn) { (, amountsIn) = abi.decode(self, (JoinKind, uint256[])); } function exactTokensInForBptOut(bytes memory self) internal pure returns (uint256[] memory amountsIn, uint256 minBPTAmountOut) { (, amountsIn, minBPTAmountOut) = abi.decode(self, (JoinKind, uint256[], uint256)); } function tokenInForExactBptOut(bytes memory self) internal pure returns (uint256 bptAmountOut, uint256 tokenIndex) { (, bptAmountOut, tokenIndex) = abi.decode(self, (JoinKind, uint256, uint256)); } function allTokensInForExactBptOut(bytes memory self) internal pure returns (uint256 bptAmountOut) { (, bptAmountOut) = abi.decode(self, (JoinKind, uint256)); } // Exits function exactBptInForTokenOut(bytes memory self) internal pure returns (uint256 bptAmountIn, uint256 tokenIndex) { (, bptAmountIn, tokenIndex) = abi.decode(self, (ExitKind, uint256, uint256)); } function exactBptInForTokensOut(bytes memory self) internal pure returns (uint256 bptAmountIn) { (, bptAmountIn) = abi.decode(self, (ExitKind, uint256)); } function bptInForExactTokensOut(bytes memory self) internal pure returns (uint256[] memory amountsOut, uint256 maxBPTAmountIn) { (, amountsOut, maxBPTAmountIn) = abi.decode(self, (ExitKind, uint256[], uint256)); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @notice Simple interface to retrieve the version of a deployed contract. */ interface IVersion { /** * @dev Returns a JSON representation of the contract version containing name, version number and task ID. */ function version() external view returns (string memory); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @notice Simple interface to retrieve the version of pools deployed by a pool factory. */ interface IFactoryCreatedPoolVersion { /** * @dev Returns a JSON representation of the deployed pool version containing name, version number and task ID. * * This is typically only useful in complex Pool deployment schemes, where multiple subsystems need to know about * each other. Note that this value will only be updated at factory creation time. */ function getPoolVersion() external view returns (string memory); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @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); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @dev Interface for WETH9. * See https://github.com/gnosis/canonical-weth/blob/0dd1ea3e295eef916d0c6223ec63141137d22d67/contracts/WETH9.sol */ interface IWETH is IERC20 { function deposit() external payable; function withdraw(uint256 amount) external; } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // 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; } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. interface IProtocolFeesCollector { event SwapFeePercentageChanged(uint256 newSwapFeePercentage); event FlashLoanFeePercentageChanged(uint256 newFlashLoanFeePercentage); function withdrawCollectedFees( IERC20[] calldata tokens, uint256[] calldata amounts, address recipient ) external; function setSwapFeePercentage(uint256 newSwapFeePercentage) external; function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external; function getSwapFeePercentage() external view returns (uint256); function getFlashLoanFeePercentage() external view returns (uint256); function getCollectedFeeAmounts(IERC20[] memory tokens) external view returns (uint256[] memory feeAmounts); function getAuthorizer() external view returns (IAuthorizer); function vault() external view returns (IVault); } /** * @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, IAuthentication { // 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 (IProtocolFeesCollector); /** * @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 } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. interface IBasePoolFactory is IAuthentication { /** * @dev Returns true if `pool` was created by this factory. */ function isPoolFromFactory(address pool) external view returns (bool); /** * @dev Check whether the derived factory has been disabled. */ function isDisabled() external view returns (bool); /** * @dev Disable the factory, preventing the creation of more pools. Already existing pools are unaffected. * Once a factory is disabled, it cannot be re-enabled. */ function disable() external; } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @dev Library used to deploy contracts with specific code. This can be used for long-term storage of immutable data as * contract code, which can be retrieved via the `extcodecopy` opcode. */ library CodeDeployer { // During contract construction, the full code supplied exists as code, and can be accessed via `codesize` and // `codecopy`. This is not the contract's final code however: whatever the constructor returns is what will be // stored as its code. // // We use this mechanism to have a simple constructor that stores whatever is appended to it. The following opcode // sequence corresponds to the creation code of the following equivalent Solidity contract, plus padding to make the // full code 32 bytes long: // // contract CodeDeployer { // constructor() payable { // uint256 size; // assembly { // size := sub(codesize(), 32) // size of appended data, as constructor is 32 bytes long // codecopy(0, 32, size) // copy all appended data to memory at position 0 // return(0, size) // return appended data for it to be stored as code // } // } // } // // More specifically, it is composed of the following opcodes (plus padding): // // [1] PUSH1 0x20 // [2] CODESIZE // [3] SUB // [4] DUP1 // [6] PUSH1 0x20 // [8] PUSH1 0x00 // [9] CODECOPY // [11] PUSH1 0x00 // [12] RETURN // // The padding is just the 0xfe sequence (invalid opcode). It is important as it lets us work in-place, avoiding // memory allocation and copying. bytes32 private constant _DEPLOYER_CREATION_CODE = 0x602038038060206000396000f3fefefefefefefefefefefefefefefefefefefe; /** * @dev Deploys a contract with `code` as its code, returning the destination address. * * Reverts if deployment fails. */ function deploy(bytes memory code) internal returns (address destination) { bytes32 deployerCreationCode = _DEPLOYER_CREATION_CODE; // We need to concatenate the deployer creation code and `code` in memory, but want to avoid copying all of // `code` (which could be quite long) into a new memory location. Therefore, we operate in-place using // assembly. // solhint-disable-next-line no-inline-assembly assembly { let codeLength := mload(code) // `code` is composed of length and data. We've already stored its length in `codeLength`, so we simply // replace it with the deployer creation code (which is exactly 32 bytes long). mstore(code, deployerCreationCode) // At this point, `code` now points to the deployer creation code immediately followed by `code`'s data // contents. This is exactly what the deployer expects to receive when created. destination := create(0, code, add(codeLength, 32)) // Finally, we restore the original length in order to not mutate `code`. mstore(code, codeLength) } // The create opcode returns the zero address when contract creation fails, so we revert if this happens. _require(destination != address(0), Errors.CODE_DEPLOYMENT_FAILED); } } /** * @dev Base factory for contracts whose creation code is so large that the factory cannot hold it. This happens when * the contract's creation code grows close to 24kB. * * Note that this factory cannot help with contracts that have a *runtime* (deployed) bytecode larger than 24kB. */ abstract contract BaseSplitCodeFactory { // The contract's creation code is stored as code in two separate addresses, and retrieved via `extcodecopy`. This // means this factory supports contracts with creation code of up to 48kB. // We rely on inline-assembly to achieve this, both to make the entire operation highly gas efficient, and because // `extcodecopy` is not available in Solidity. // solhint-disable no-inline-assembly address private immutable _creationCodeContractA; uint256 private immutable _creationCodeSizeA; address private immutable _creationCodeContractB; uint256 private immutable _creationCodeSizeB; /** * @dev The creation code of a contract Foo can be obtained inside Solidity with `type(Foo).creationCode`. */ constructor(bytes memory creationCode) { uint256 creationCodeSize = creationCode.length; // We are going to deploy two contracts: one with approximately the first half of `creationCode`'s contents // (A), and another with the remaining half (B). // We store the lengths in both immutable and stack variables, since immutable variables cannot be read during // construction. uint256 creationCodeSizeA = creationCodeSize / 2; _creationCodeSizeA = creationCodeSizeA; uint256 creationCodeSizeB = creationCodeSize - creationCodeSizeA; _creationCodeSizeB = creationCodeSizeB; // To deploy the contracts, we're going to use `CodeDeployer.deploy()`, which expects a memory array with // the code to deploy. Note that we cannot simply create arrays for A and B's code by copying or moving // `creationCode`'s contents as they are expected to be very large (> 24kB), so we must operate in-place. // Memory: [ code length ] [ A.data ] [ B.data ] // Creating A's array is simple: we simply replace `creationCode`'s length with A's length. We'll later restore // the original length. bytes memory creationCodeA; assembly { creationCodeA := creationCode mstore(creationCodeA, creationCodeSizeA) } // Memory: [ A.length ] [ A.data ] [ B.data ] // ^ creationCodeA _creationCodeContractA = CodeDeployer.deploy(creationCodeA); // Creating B's array is a bit more involved: since we cannot move B's contents, we are going to create a 'new' // memory array starting at A's last 32 bytes, which will be replaced with B's length. We'll back-up this last // byte to later restore it. bytes memory creationCodeB; bytes32 lastByteA; assembly { // `creationCode` points to the array's length, not data, so by adding A's length to it we arrive at A's // last 32 bytes. creationCodeB := add(creationCode, creationCodeSizeA) lastByteA := mload(creationCodeB) mstore(creationCodeB, creationCodeSizeB) } // Memory: [ A.length ] [ A.data[ : -1] ] [ B.length ][ B.data ] // ^ creationCodeA ^ creationCodeB _creationCodeContractB = CodeDeployer.deploy(creationCodeB); // We now restore the original contents of `creationCode` by writing back the original length and A's last byte. assembly { mstore(creationCodeA, creationCodeSize) mstore(creationCodeB, lastByteA) } } /** * @dev Returns the two addresses where the creation code of the contract crated by this factory is stored. */ function getCreationCodeContracts() public view returns (address contractA, address contractB) { return (_creationCodeContractA, _creationCodeContractB); } /** * @dev Returns the creation code of the contract this factory creates. */ function getCreationCode() public view returns (bytes memory) { return _getCreationCodeWithArgs(""); } /** * @dev Returns the creation code that will result in a contract being deployed with `constructorArgs`. */ function _getCreationCodeWithArgs(bytes memory constructorArgs) private view returns (bytes memory code) { // This function exists because `abi.encode()` cannot be instructed to place its result at a specific address. // We need for the ABI-encoded constructor arguments to be located immediately after the creation code, but // cannot rely on `abi.encodePacked()` to perform concatenation as that would involve copying the creation code, // which would be prohibitively expensive. // Instead, we compute the creation code in a pre-allocated array that is large enough to hold *both* the // creation code and the constructor arguments, and then copy the ABI-encoded arguments (which should not be // overly long) right after the end of the creation code. // Immutable variables cannot be used in assembly, so we store them in the stack first. address creationCodeContractA = _creationCodeContractA; uint256 creationCodeSizeA = _creationCodeSizeA; address creationCodeContractB = _creationCodeContractB; uint256 creationCodeSizeB = _creationCodeSizeB; uint256 creationCodeSize = creationCodeSizeA + creationCodeSizeB; uint256 constructorArgsSize = constructorArgs.length; uint256 codeSize = creationCodeSize + constructorArgsSize; assembly { // First, we allocate memory for `code` by retrieving the free memory pointer and then moving it ahead of // `code` by the size of the creation code plus constructor arguments, and 32 bytes for the array length. code := mload(0x40) mstore(0x40, add(code, add(codeSize, 32))) // We now store the length of the code plus constructor arguments. mstore(code, codeSize) // Next, we concatenate the creation code stored in A and B. let dataStart := add(code, 32) extcodecopy(creationCodeContractA, dataStart, 0, creationCodeSizeA) extcodecopy(creationCodeContractB, add(dataStart, creationCodeSizeA), 0, creationCodeSizeB) } // Finally, we copy the constructorArgs to the end of the array. Unfortunately there is no way to avoid this // copy, as it is not possible to tell Solidity where to store the result of `abi.encode()`. uint256 constructorArgsDataPtr; uint256 constructorArgsCodeDataPtr; assembly { constructorArgsDataPtr := add(constructorArgs, 32) constructorArgsCodeDataPtr := add(add(code, 32), creationCodeSize) } _memcpy(constructorArgsCodeDataPtr, constructorArgsDataPtr, constructorArgsSize); } /** * @dev Deploys a contract with constructor arguments. To create `constructorArgs`, call `abi.encode()` with the * contract's constructor arguments, in order. */ function _create(bytes memory constructorArgs) internal virtual returns (address) { bytes memory creationCode = _getCreationCodeWithArgs(constructorArgs); address destination; assembly { destination := create(0, add(creationCode, 32), mload(creationCode)) } if (destination == address(0)) { // Bubble up inner revert reason // solhint-disable-next-line no-inline-assembly assembly { returndatacopy(0, 0, returndatasize()) revert(0, returndatasize()) } } return destination; } // From // https://github.com/Arachnid/solidity-stringutils/blob/b9a6f6615cf18a87a823cbc461ce9e140a61c305/src/strings.sol function _memcpy( uint256 dest, uint256 src, uint256 len ) private pure { // Copy word-length chunks while possible for (; len >= 32; len -= 32) { assembly { mstore(dest, mload(src)) } dest += 32; src += 32; } // Copy remaining bytes uint256 mask = 256**(32 - len) - 1; assembly { let srcpart := and(mload(src), not(mask)) let destpart := and(mload(dest), mask) mstore(dest, or(destpart, srcpart)) } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. interface IAuthorizerAdaptor is IAuthentication { /** * @notice Returns the Balancer Vault */ function getVault() external view returns (IVault); /** * @notice Returns the Authorizer */ function getAuthorizer() external view returns (IAuthorizer); /** * @notice Performs an arbitrary function call on a target contract, provided the caller is authorized to do so. * @param target - Address of the contract to be called * @param data - Calldata to be sent to the target contract * @return The bytes encoded return value from the performed function call */ function performAction(address target, bytes calldata data) external payable returns (bytes memory); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @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); } abstract contract SingletonAuthentication is Authentication { IVault private immutable _vault; // Use the contract's own address to disambiguate action identifiers constructor(IVault vault) Authentication(bytes32(uint256(address(this)))) { _vault = vault; } /** * @notice Returns the Balancer Vault */ function getVault() public view returns (IVault) { return _vault; } /** * @notice Returns the Authorizer */ function getAuthorizer() public view returns (IAuthorizer) { return getVault().getAuthorizer(); } function _canPerform(bytes32 actionId, address account) internal view override returns (bool) { return getAuthorizer().canPerform(actionId, account, address(this)); } function _canPerform( bytes32 actionId, address account, address where ) internal view returns (bool) { return getAuthorizer().canPerform(actionId, account, where); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @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 immutable _pauseWindowEndTime; uint256 private immutable _bufferPeriodEndTime; bool private _paused; constructor(uint256 pauseWindowDuration, uint256 bufferPeriodDuration) { _require(pauseWindowDuration <= PausableConstants.MAX_PAUSE_WINDOW_DURATION, Errors.MAX_PAUSE_WINDOW_DURATION); _require( bufferPeriodDuration <= PausableConstants.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 Reverts if the contract is not paused. */ function _ensurePaused() internal view { _require(!_isNotPaused(), Errors.NOT_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; } } /** * @dev Keep the maximum durations in a single place. */ library PausableConstants { uint256 public constant MAX_PAUSE_WINDOW_DURATION = 270 days; uint256 public constant MAX_BUFFER_PERIOD_DURATION = 90 days; } /** * @dev Utility to create Pool factories for Pools that use the `TemporarilyPausable` contract. * * By calling `TemporarilyPausable`'s constructor with the result of `getPauseConfiguration`, all Pools created by this * factory will share the same Pause Window end time, after which both old and new Pools will not be pausable. */ contract FactoryWidePauseWindow { // This contract relies on timestamps in a similar way as `TemporarilyPausable` does - the same caveats apply. // solhint-disable not-rely-on-time uint256 private immutable _initialPauseWindowDuration; uint256 private immutable _bufferPeriodDuration; // Time when the pause window for all created Pools expires, and the pause window duration of new Pools becomes // zero. uint256 private immutable _poolsPauseWindowEndTime; constructor(uint256 initialPauseWindowDuration, uint256 bufferPeriodDuration) { // New pools will check on deployment that the durations given are within the bounds specified by // `TemporarilyPausable`. Since it is now possible for a factory to pass in arbitrary values here, // pre-emptively verify that these durations are valid for pool creation. // (Otherwise, you would be able to deploy a useless factory where `create` would always revert.) _require( initialPauseWindowDuration <= PausableConstants.MAX_PAUSE_WINDOW_DURATION, Errors.MAX_PAUSE_WINDOW_DURATION ); _require( bufferPeriodDuration <= PausableConstants.MAX_BUFFER_PERIOD_DURATION, Errors.MAX_BUFFER_PERIOD_DURATION ); _initialPauseWindowDuration = initialPauseWindowDuration; _bufferPeriodDuration = bufferPeriodDuration; _poolsPauseWindowEndTime = block.timestamp + initialPauseWindowDuration; } /** * @dev Returns the current `TemporarilyPausable` configuration that will be applied to Pools created by this * factory. * * `pauseWindowDuration` will decrease over time until it reaches zero, at which point both it and * `bufferPeriodDuration` will be zero forever, meaning deployed Pools will not be pausable. */ function getPauseConfiguration() public view returns (uint256 pauseWindowDuration, uint256 bufferPeriodDuration) { uint256 currentTime = block.timestamp; if (currentTime < _poolsPauseWindowEndTime) { // The buffer period is always the same since its duration is related to how much time is needed to respond // to a potential emergency. The Pause Window duration however decreases as the end time approaches. pauseWindowDuration = _poolsPauseWindowEndTime - currentTime; // No need for checked arithmetic. bufferPeriodDuration = _bufferPeriodDuration; } else { // After the end time, newly created Pools have no Pause Window, nor Buffer Period (since they are not // pausable in the first place). pauseWindowDuration = 0; bufferPeriodDuration = 0; } } } /** * @notice Base contract for Pool factories. * * Pools are deployed from factories to allow third parties to reason about them. Unknown Pools may have arbitrary * logic: being able to assert that a Pool's behavior follows certain rules (those imposed by the contracts created by * the factory) is very powerful. * * @dev By using the split code mechanism, we can deploy Pools with creation code so large that a regular factory * contract would not be able to store it. * * Since we expect to release new versions of pool types regularly - and the blockchain is forever - versioning will * become increasingly important. Governance can deprecate a factory by calling `disable`, which will permanently * prevent the creation of any future pools from the factory. */ abstract contract BasePoolFactory is IBasePoolFactory, BaseSplitCodeFactory, SingletonAuthentication, FactoryWidePauseWindow { IProtocolFeePercentagesProvider private immutable _protocolFeeProvider; mapping(address => bool) private _isPoolFromFactory; bool private _disabled; event PoolCreated(address indexed pool); event FactoryDisabled(); constructor( IVault vault, IProtocolFeePercentagesProvider protocolFeeProvider, uint256 initialPauseWindowDuration, uint256 bufferPeriodDuration, bytes memory creationCode ) BaseSplitCodeFactory(creationCode) SingletonAuthentication(vault) FactoryWidePauseWindow(initialPauseWindowDuration, bufferPeriodDuration) { _protocolFeeProvider = protocolFeeProvider; } function isPoolFromFactory(address pool) external view override returns (bool) { return _isPoolFromFactory[pool]; } function isDisabled() public view override returns (bool) { return _disabled; } function disable() external override authenticate { _ensureEnabled(); _disabled = true; emit FactoryDisabled(); } function _ensureEnabled() internal view { _require(!isDisabled(), Errors.DISABLED); } function getProtocolFeePercentagesProvider() public view returns (IProtocolFeePercentagesProvider) { return _protocolFeeProvider; } function _create(bytes memory constructorArgs) internal virtual override returns (address) { _ensureEnabled(); address pool = super._create(constructorArgs); _isPoolFromFactory[pool] = true; emit PoolCreated(pool); return pool; } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @notice Retrieves a contract's version set at creation time from storage. */ contract Version is IVersion { string private _version; constructor(string memory version) { _version = version; } function version() external view override returns (string memory) { return _version; } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @notice Interface for ExternalWeightedMath, a contract-wrapper for Weighted Math, Joins and Exits. */ interface IExternalWeightedMath { /** * @dev See `WeightedMath._calculateInvariant`. */ function calculateInvariant(uint256[] memory normalizedWeights, uint256[] memory balances) external pure returns (uint256); /** * @dev See `WeightedMath._calcOutGivenIn`. */ function calcOutGivenIn( uint256 balanceIn, uint256 weightIn, uint256 balanceOut, uint256 weightOut, uint256 amountIn ) external pure returns (uint256); /** * @dev See `WeightedMath._calcInGivenOut`. */ function calcInGivenOut( uint256 balanceIn, uint256 weightIn, uint256 balanceOut, uint256 weightOut, uint256 amountOut ) external pure returns (uint256); /** * @dev See `WeightedMath._calcBptOutGivenExactTokensIn`. */ function calcBptOutGivenExactTokensIn( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure returns (uint256); /** * @dev See `WeightedMath._calcBptOutGivenExactTokenIn`. */ function calcBptOutGivenExactTokenIn( uint256 balance, uint256 normalizedWeight, uint256 amountIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure returns (uint256); /** * @dev See `WeightedMath._calcTokenInGivenExactBptOut`. */ function calcTokenInGivenExactBptOut( uint256 balance, uint256 normalizedWeight, uint256 bptAmountOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure returns (uint256); /** * @dev See `WeightedMath._calcAllTokensInGivenExactBptOut`. */ function calcAllTokensInGivenExactBptOut( uint256[] memory balances, uint256 bptAmountOut, uint256 totalBPT ) external pure returns (uint256[] memory); /** * @dev See `WeightedMath._calcBptInGivenExactTokensOut`. */ function calcBptInGivenExactTokensOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure returns (uint256); /** * @dev See `WeightedMath._calcBptInGivenExactTokenOut`. */ function calcBptInGivenExactTokenOut( uint256 balance, uint256 normalizedWeight, uint256 amountOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure returns (uint256); /** * @dev See `WeightedMath._calcTokenOutGivenExactBptIn`. */ function calcTokenOutGivenExactBptIn( uint256 balance, uint256 normalizedWeight, uint256 bptAmountIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure returns (uint256); /** * @dev See `WeightedMath._calcTokensOutGivenExactBptIn`. */ function calcTokensOutGivenExactBptIn( uint256[] memory balances, uint256 bptAmountIn, uint256 totalBPT ) external pure returns (uint256[] memory); /** * @dev See `WeightedMath._calcBptOutAddToken`. */ function calcBptOutAddToken(uint256 totalSupply, uint256 normalizedWeight) external pure returns (uint256); /** * @dev See `WeightedJoinsLib.joinExactTokensInForBPTOut`. */ function joinExactTokensInForBPTOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure returns (uint256, uint256[] memory); /** * @dev See `WeightedJoinsLib.joinTokenInForExactBPTOut`. */ function joinTokenInForExactBPTOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure returns (uint256, uint256[] memory); /** * @dev See `WeightedJoinsLib.joinAllTokensInForExactBPTOut`. */ function joinAllTokensInForExactBPTOut( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) external pure returns (uint256 bptAmountOut, uint256[] memory amountsIn); /** * @dev See `WeightedExitsLib.exitExactBPTInForTokenOut`. */ function exitExactBPTInForTokenOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure returns (uint256, uint256[] memory); /** * @dev See `WeightedExitsLib.exitExactBPTInForTokensOut`. */ function exitExactBPTInForTokensOut( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) external pure returns (uint256 bptAmountIn, uint256[] memory amountsOut); /** * @dev See `WeightedExitsLib.exitBPTInForExactTokensOut`. */ function exitBPTInForExactTokensOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure returns (uint256, uint256[] memory); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated // documentation files (the “Software”), to deal in the Software without restriction, including without limitation the // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to // permit persons to whom the Software is furnished to do so, subject to the following conditions: // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the // Software. // THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* 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 >> 255 == 0, 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 Logarithm (log(arg, base), with signed 18 decimal fixed point base and 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 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 (LN_36_LOWER_BOUND < a && a < LN_36_UPPER_BOUND) { return _ln_36(a) / ONE_18; } else { return _ln(a); } } /** * @dev Internal natural logarithm (ln(a)) with signed 18 decimal fixed point argument. */ function _ln(int256 a) private pure returns (int256) { 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 Intrnal 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; } } /* solhint-disable private-vars-leading-underscore */ library FixedPoint { // solhint-disable no-inline-assembly uint256 internal constant ONE = 1e18; // 18 decimal places uint256 internal constant TWO = 2 * ONE; uint256 internal constant FOUR = 4 * ONE; 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 result) { uint256 product = a * b; _require(a == 0 || product / a == b, Errors.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, if x == 0 then the result is zero // // Equivalent to: // result = product == 0 ? 0 : ((product - 1) / FixedPoint.ONE) + 1; assembly { result := mul(iszero(iszero(product)), add(div(sub(product, 1), ONE), 1)) } } function divDown(uint256 a, uint256 b) internal pure returns (uint256) { _require(b != 0, Errors.ZERO_DIVISION); uint256 aInflated = a * ONE; _require(a == 0 || aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow return aInflated / b; } function divUp(uint256 a, uint256 b) internal pure returns (uint256 result) { _require(b != 0, Errors.ZERO_DIVISION); uint256 aInflated = a * ONE; _require(a == 0 || 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, if x == 0 then the result is zero // // Equivalent to: // result = a == 0 ? 0 : (a * FixedPoint.ONE - 1) / b + 1; assembly { result := mul(iszero(iszero(aInflated)), add(div(sub(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) { // Optimize for when y equals 1.0, 2.0 or 4.0, as those are very simple to implement and occur often in 50/50 // and 80/20 Weighted Pools if (y == ONE) { return x; } else if (y == TWO) { return mulDown(x, x); } else if (y == FOUR) { uint256 square = mulDown(x, x); return mulDown(square, square); } else { 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) { // Optimize for when y equals 1.0, 2.0 or 4.0, as those are very simple to implement and occur often in 50/50 // and 80/20 Weighted Pools if (y == ONE) { return x; } else if (y == TWO) { return mulUp(x, x); } else if (y == FOUR) { uint256 square = mulUp(x, x); return mulUp(square, square); } else { 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 result) { // Equivalent to: // result = (x < ONE) ? (ONE - x) : 0; assembly { result := mul(lt(x, ONE), sub(ONE, x)) } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. 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(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; } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library BasePoolMath { using FixedPoint for uint256; function computeProportionalAmountsIn( uint256[] memory balances, uint256 bptTotalSupply, uint256 bptAmountOut ) internal pure returns (uint256[] memory amountsIn) { /************************************************************************************ // computeProportionalAmountsIn // // (per token) // // aI = amountIn / bptOut \ // // b = balance aI = b * | ----------------- | // // bptOut = bptAmountOut \ bptTotalSupply / // // bpt = bptTotalSupply // ************************************************************************************/ // Since we're computing amounts in, we round up overall. This means rounding up on both the // multiplication and division. uint256 bptRatio = bptAmountOut.divUp(bptTotalSupply); amountsIn = new uint256[](balances.length); for (uint256 i = 0; i < balances.length; i++) { amountsIn[i] = balances[i].mulUp(bptRatio); } } function computeProportionalAmountsOut( uint256[] memory balances, uint256 bptTotalSupply, uint256 bptAmountIn ) internal pure returns (uint256[] memory amountsOut) { /********************************************************************************************** // computeProportionalAmountsOut // // (per token) // // aO = tokenAmountOut / bptIn \ // // b = tokenBalance a0 = b * | --------------------- | // // bptIn = bptAmountIn \ bptTotalSupply / // // bpt = bptTotalSupply // **********************************************************************************************/ // Since we're computing an amount out, we round down overall. This means rounding down on both the // multiplication and division. uint256 bptRatio = bptAmountIn.divDown(bptTotalSupply); amountsOut = new uint256[](balances.length); for (uint256 i = 0; i < balances.length; i++) { amountsOut[i] = balances[i].mulDown(bptRatio); } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // solhint-disable no-inline-assembly library ComposablePoolLib { using FixedPoint for uint256; /** * @notice Returns a slice of the original array, with the BPT token address removed. * @dev *This mutates the original array*, which should not be used anymore after calling this function. * It's recommended to call this function such that the calling function either immediately returns or overwrites * the original array variable so it cannot be accessed. */ function dropBptFromTokens(IERC20[] memory registeredTokens) internal pure returns (IERC20[] memory tokens) { assembly { // An array's memory representation is a 32 byte word for the length followed by 32 byte words for // each element, with the stack variable pointing to the length. Since there's no memory deallocation, // and we are free to mutate the received array, the cheapest way to remove the first element is to // create a new subarray by overwriting the first element with a reduced length, and moving the pointer // forward to that position. // // Original: // [ length ] [ data[0] ] [ data[1] ] [ ... ] // ^ pointer // // Modified: // [ length ] [ length - 1 ] [ data[1] ] [ ... ] // ^ pointer // // Note that this can only be done if the element to remove is the first one, which is one of the reasons // why Composable Pools register BPT as the first token. mstore(add(registeredTokens, 32), sub(mload(registeredTokens), 1)) tokens := add(registeredTokens, 32) } } /** * @notice Returns the virtual supply, and a slice of the original balances array with the BPT balance removed. * @dev *This mutates the original array*, which should not be used anymore after calling this function. * It's recommended to call this function such that the calling function either immediately returns or overwrites * the original array variable so it cannot be accessed. */ function dropBptFromBalances(uint256 totalSupply, uint256[] memory registeredBalances) internal pure returns (uint256 virtualSupply, uint256[] memory balances) { virtualSupply = totalSupply.sub(registeredBalances[0]); assembly { // See dropBptFromTokens for a detailed explanation of how this works. mstore(add(registeredBalances, 32), sub(mload(registeredBalances), 1)) balances := add(registeredBalances, 32) } } /** * @notice Returns slices of the original arrays, with the BPT token address and balance removed. * @dev *This mutates the original arrays*, which should not be used anymore after calling this function. * It's recommended to call this function such that the calling function either immediately returns or overwrites * the original array variable so it cannot be accessed. */ function dropBpt(IERC20[] memory registeredTokens, uint256[] memory registeredBalances) internal pure returns (IERC20[] memory tokens, uint256[] memory balances) { assembly { // See dropBptFromTokens for a detailed explanation of how this works mstore(add(registeredTokens, 32), sub(mload(registeredTokens), 1)) tokens := add(registeredTokens, 32) mstore(add(registeredBalances, 32), sub(mload(registeredBalances), 1)) balances := add(registeredBalances, 32) } } /** * @notice Returns the passed array prepended with a zero element. */ function prependZeroElement(uint256[] memory array) internal pure returns (uint256[] memory prependedArray) { prependedArray = new uint256[](array.length + 1); for (uint256 i = 0; i < array.length; i++) { prependedArray[i + 1] = array[i]; } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library PoolRegistrationLib { function registerPool( IVault vault, IVault.PoolSpecialization specialization, IERC20[] memory tokens ) internal returns (bytes32) { return registerPoolWithAssetManagers(vault, specialization, tokens, new address[](tokens.length)); } function registerPoolWithAssetManagers( IVault vault, IVault.PoolSpecialization specialization, IERC20[] memory tokens, address[] memory assetManagers ) internal returns (bytes32) { // The Vault only requires the token list to be ordered for the Two Token Pools specialization. However, // to make the developer experience consistent, we are requiring this condition for all the native pools. // // Note that for Pools which can register and deregister tokens after deployment, this property may not hold // as tokens which are added to the Pool after deployment are always added to the end of the array. InputHelpers.ensureArrayIsSorted(tokens); return _registerPool(vault, specialization, tokens, assetManagers); } function registerComposablePool( IVault vault, IVault.PoolSpecialization specialization, IERC20[] memory tokens, address[] memory assetManagers ) internal returns (bytes32) { // The Vault only requires the token list to be ordered for the Two Token Pools specialization. However, // to make the developer experience consistent, we are requiring this condition for all the native pools. // // Note that for Pools which can register and deregister tokens after deployment, this property may not hold // as tokens which are added to the Pool after deployment are always added to the end of the array. InputHelpers.ensureArrayIsSorted(tokens); IERC20[] memory composableTokens = new IERC20[](tokens.length + 1); // We insert the Pool's BPT address into the first position. // This allows us to know the position of the BPT token in the tokens array without explicitly tracking it. // When deregistering a token, the token at the end of the array is moved into the index of the deregistered // token, changing its index. By placing BPT at the beginning of the tokens array we can be sure that its index // will never change unless it is deregistered itself (something which composable pools must prevent anyway). composableTokens[0] = IERC20(address(this)); for (uint256 i = 0; i < tokens.length; i++) { composableTokens[i + 1] = tokens[i]; } address[] memory composableAssetManagers = new address[](assetManagers.length + 1); // We do not allow an asset manager for the Pool's BPT. composableAssetManagers[0] = address(0); for (uint256 i = 0; i < assetManagers.length; i++) { composableAssetManagers[i + 1] = assetManagers[i]; } return _registerPool(vault, specialization, composableTokens, composableAssetManagers); } function _registerPool( IVault vault, IVault.PoolSpecialization specialization, IERC20[] memory tokens, address[] memory assetManagers ) private returns (bytes32) { bytes32 poolId = vault.registerPool(specialization); // We don't need to check that tokens and assetManagers have the same length, since the Vault already performs // that check. vault.registerTokens(poolId, tokens, assetManagers); return poolId; } function registerToken( IVault vault, bytes32 poolId, IERC20 token, address assetManager ) internal { IERC20[] memory tokens = new IERC20[](1); tokens[0] = token; address[] memory assetManagers = new address[](1); assetManagers[0] = assetManager; vault.registerTokens(poolId, tokens, assetManagers); } function deregisterToken( IVault vault, bytes32 poolId, IERC20 token ) internal { IERC20[] memory tokens = new IERC20[](1); tokens[0] = token; vault.deregisterTokens(poolId, tokens); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. 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; } } /** * @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). `balances` 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. `balances` 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); /** * @dev Returns this Pool's ID, used when interacting with the Vault (to e.g. join the Pool or swap with it). */ function getPoolId() external view returns (bytes32); /** * @dev Returns the current swap fee percentage as a 18 decimal fixed point number, so e.g. 1e17 corresponds to a * 10% swap fee. */ function getSwapFeePercentage() external view returns (uint256); /** * @dev Returns the scaling factors of each of the Pool's tokens. This is an implementation detail that is typically * not relevant for outside parties, but which might be useful for some types of Pools. */ function getScalingFactors() external view returns (uint256[] memory); function queryJoin( bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData ) external returns (uint256 bptOut, uint256[] memory amountsIn); function queryExit( bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData ) external returns (uint256 bptIn, uint256[] memory amountsOut); } interface IManagedPool is IBasePool { event GradualSwapFeeUpdateScheduled( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ); event GradualWeightUpdateScheduled( uint256 startTime, uint256 endTime, uint256[] startWeights, uint256[] endWeights ); event SwapEnabledSet(bool swapEnabled); event JoinExitEnabledSet(bool joinExitEnabled); event MustAllowlistLPsSet(bool mustAllowlistLPs); event AllowlistAddressAdded(address indexed member); event AllowlistAddressRemoved(address indexed member); event ManagementAumFeePercentageChanged(uint256 managementAumFeePercentage); event ManagementAumFeeCollected(uint256 bptAmount); event CircuitBreakerSet( IERC20 indexed token, uint256 bptPrice, uint256 lowerBoundPercentage, uint256 upperBoundPercentage ); event TokenAdded(IERC20 indexed token, uint256 normalizedWeight); event TokenRemoved(IERC20 indexed token); /** * @notice Returns the effective BPT supply. * * @dev The Pool owes debt to the Protocol and the Pool's owner in the form of unminted BPT, which will be minted * immediately before the next join or exit. We need to take these into account since, even if they don't yet exist, * they will effectively be included in any Pool operation that involves BPT. * * In the vast majority of cases, this function should be used instead of `totalSupply()`. */ function getActualSupply() external view returns (uint256); // Swap fee percentage /** * @notice Schedule a gradual swap fee update. * @dev The swap fee will change from the given starting value (which may or may not be the current * value) to the given ending fee percentage, over startTime to endTime. * * Note that calling this with a starting swap fee different from the current value will immediately change the * current swap fee to `startSwapFeePercentage`, before commencing the gradual change at `startTime`. * Emits the GradualSwapFeeUpdateScheduled event. * This is a permissioned function. * * @param startTime - The timestamp when the swap fee change will begin. * @param endTime - The timestamp when the swap fee change will end (must be >= startTime). * @param startSwapFeePercentage - The starting value for the swap fee change. * @param endSwapFeePercentage - The ending value for the swap fee change. If the current timestamp >= endTime, * `getSwapFeePercentage()` will return this value. */ function updateSwapFeeGradually( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) external; /** * @notice Returns the current gradual swap fee update parameters. * @dev The current swap fee can be retrieved via `getSwapFeePercentage()`. * @return startTime - The timestamp when the swap fee update will begin. * @return endTime - The timestamp when the swap fee update will end. * @return startSwapFeePercentage - The starting swap fee percentage (could be different from the current value). * @return endSwapFeePercentage - The final swap fee percentage, when the current timestamp >= endTime. */ function getGradualSwapFeeUpdateParams() external view returns ( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ); // Token weights /** * @notice Schedule a gradual weight change. * @dev The weights will change from their current values to the given endWeights, over startTime to endTime. * This is a permissioned function. * * Since, unlike with swap fee updates, we generally do not want to allow instantaneous weight changes, * the weights always start from their current values. This also guarantees a smooth transition when * updateWeightsGradually is called during an ongoing weight change. * @param startTime - The timestamp when the weight change will begin. * @param endTime - The timestamp when the weight change will end (can be >= startTime). * @param tokens - The tokens associated with the target weights (must match the current pool tokens). * @param endWeights - The target weights. If the current timestamp >= endTime, `getNormalizedWeights()` * will return these values. */ function updateWeightsGradually( uint256 startTime, uint256 endTime, IERC20[] memory tokens, uint256[] memory endWeights ) external; /** * @notice Returns all normalized weights, in the same order as the Pool's tokens. */ function getNormalizedWeights() external view returns (uint256[] memory); /** * @notice Returns the current gradual weight change update parameters. * @dev The current weights can be retrieved via `getNormalizedWeights()`. * @return startTime - The timestamp when the weight update will begin. * @return endTime - The timestamp when the weight update will end. * @return startWeights - The starting weights, when the weight change was initiated. * @return endWeights - The final weights, when the current timestamp >= endTime. */ function getGradualWeightUpdateParams() external view returns ( uint256 startTime, uint256 endTime, uint256[] memory startWeights, uint256[] memory endWeights ); // Join and Exit enable/disable /** * @notice Enable or disable joins and exits. Note that this does not affect Recovery Mode exits. * @dev Emits the JoinExitEnabledSet event. This is a permissioned function. * @param joinExitEnabled - The new value of the join/exit enabled flag. */ function setJoinExitEnabled(bool joinExitEnabled) external; /** * @notice Returns whether joins and exits are enabled. */ function getJoinExitEnabled() external view returns (bool); // Swap enable/disable /** * @notice Enable or disable trading. * @dev Emits the SwapEnabledSet event. This is a permissioned function. * @param swapEnabled - The new value of the swap enabled flag. */ function setSwapEnabled(bool swapEnabled) external; /** * @notice Returns whether swaps are enabled. */ function getSwapEnabled() external view returns (bool); // LP Allowlist /** * @notice Enable or disable the LP allowlist. * @dev Note that any addresses added to the allowlist will be retained if the allowlist is toggled off and * back on again, because this action does not affect the list of LP addresses. * Emits the MustAllowlistLPsSet event. This is a permissioned function. * @param mustAllowlistLPs - The new value of the mustAllowlistLPs flag. */ function setMustAllowlistLPs(bool mustAllowlistLPs) external; /** * @notice Adds an address to the LP allowlist. * @dev Will fail if the address is already allowlisted. * Emits the AllowlistAddressAdded event. This is a permissioned function. * @param member - The address to be added to the allowlist. */ function addAllowedAddress(address member) external; /** * @notice Removes an address from the LP allowlist. * @dev Will fail if the address was not previously allowlisted. * Emits the AllowlistAddressRemoved event. This is a permissioned function. * @param member - The address to be removed from the allowlist. */ function removeAllowedAddress(address member) external; /** * @notice Returns whether the allowlist for LPs is enabled. */ function getMustAllowlistLPs() external view returns (bool); /** * @notice Check whether an LP address is on the allowlist. * @dev This simply checks the list, regardless of whether the allowlist feature is enabled. * @param member - The address to check against the allowlist. * @return true if the given address is on the allowlist. */ function isAddressOnAllowlist(address member) external view returns (bool); // Management fees /** * @notice Collect any accrued AUM fees and send them to the pool manager. * @dev This can be called by anyone to collect accrued AUM fees - and will be called automatically * whenever the supply changes (e.g., joins and exits, add and remove token), and before the fee * percentage is changed by the manager, to prevent fees from being applied retroactively. * @return The amount of BPT minted to the manager. */ function collectAumManagementFees() external returns (uint256); /** * @notice Setter for the yearly percentage AUM management fee, which is payable to the pool manager. * @dev Attempting to collect AUM fees in excess of the maximum permitted percentage will revert. * To avoid retroactive fee increases, we force collection at the current fee percentage before processing * the update. Emits the ManagementAumFeePercentageChanged event. This is a permissioned function. * @param managementAumFeePercentage - The new management AUM fee percentage. * @return amount - The amount of BPT minted to the manager before the update, if any. */ function setManagementAumFeePercentage(uint256 managementAumFeePercentage) external returns (uint256); /** * @notice Returns the management AUM fee percentage as an 18-decimal fixed point number and the timestamp of the * last collection of AUM fees. */ function getManagementAumFeeParams() external view returns (uint256 aumFeePercentage, uint256 lastCollectionTimestamp); // Circuit Breakers /** * @notice Set a circuit breaker for one or more tokens. * @dev This is a permissioned function. The lower and upper bounds are percentages, corresponding to a * relative change in the token's spot price: e.g., a lower bound of 0.8 means the breaker should prevent * trades that result in the value of the token dropping 20% or more relative to the rest of the pool. */ function setCircuitBreakers( IERC20[] memory tokens, uint256[] memory bptPrices, uint256[] memory lowerBoundPercentages, uint256[] memory upperBoundPercentages ) external; /** * @notice Return the full circuit breaker state for the given token. * @dev These are the reference values (BPT price and reference weight) passed in when the breaker was set, * along with the percentage bounds. It also returns the current BPT price bounds, needed to check whether * the circuit breaker should trip. */ function getCircuitBreakerState(IERC20 token) external view returns ( uint256 bptPrice, uint256 referenceWeight, uint256 lowerBound, uint256 upperBound, uint256 lowerBptPriceBound, uint256 upperBptPriceBound ); // Add/remove tokens /** * @notice Adds a token to the Pool's list of tradeable tokens. This is a permissioned function. * * @dev By adding a token to the Pool's composition, the weights of all other tokens will be decreased. The new * token will have no balance - it is up to the owner to provide some immediately after calling this function. * Note however that regular join functions will not work while the new token has no balance: the only way to * deposit an initial amount is by using an Asset Manager. * * Token addition is forbidden during a weight change, or if one is scheduled to happen in the future. * * The caller may additionally pass a non-zero `mintAmount` to have some BPT be minted for them, which might be * useful in some scenarios to account for the fact that the Pool will have more tokens. * * Emits the TokenAdded event. * * @param tokenToAdd - The ERC20 token to be added to the Pool. * @param assetManager - The Asset Manager for the token. * @param tokenToAddNormalizedWeight - The normalized weight of `token` relative to the other tokens in the Pool. * @param mintAmount - The amount of BPT to be minted as a result of adding `token` to the Pool. * @param recipient - The address to receive the BPT minted by the Pool. */ function addToken( IERC20 tokenToAdd, address assetManager, uint256 tokenToAddNormalizedWeight, uint256 mintAmount, address recipient ) external; /** * @notice Removes a token from the Pool's list of tradeable tokens. * @dev Tokens can only be removed if the Pool has more than 2 tokens, as it can never have fewer than 2 (not * including BPT). Token removal is also forbidden during a weight change, or if one is scheduled to happen in * the future. * * Emits the TokenRemoved event. This is a permissioned function. * * The caller may additionally pass a non-zero `burnAmount` to burn some of their BPT, which might be useful * in some scenarios to account for the fact that the Pool now has fewer tokens. This is a permissioned function. * @param tokenToRemove - The ERC20 token to be removed from the Pool. * @param burnAmount - The amount of BPT to be burned after removing `token` from the Pool. * @param sender - The address to burn BPT from. */ function removeToken( IERC20 tokenToRemove, uint256 burnAmount, address sender ) external; } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // solhint-disable function _asIAsset(IERC20[] memory tokens) pure returns (IAsset[] memory assets) { // solhint-disable-next-line no-inline-assembly assembly { assets := tokens } } function _sortTokens( IERC20 tokenA, IERC20 tokenB ) pure returns (IERC20[] memory tokens) { bool aFirst = tokenA < tokenB; IERC20[] memory sortedTokens = new IERC20[](2); sortedTokens[0] = aFirst ? tokenA : tokenB; sortedTokens[1] = aFirst ? tokenB : tokenA; return sortedTokens; } function _insertSorted(IERC20[] memory tokens, IERC20 token) pure returns (IERC20[] memory sorted) { sorted = new IERC20[](tokens.length + 1); if (tokens.length == 0) { sorted[0] = token; return sorted; } uint256 i; for (i = tokens.length; i > 0 && tokens[i - 1] > token; i--) sorted[i] = tokens[i - 1]; for (uint256 j = 0; j < i; j++) sorted[j] = tokens[j]; sorted[i] = token; } function _findTokenIndex(IERC20[] memory tokens, IERC20 token) pure returns (uint256) { // Note that while we know tokens are initially sorted, we cannot assume this will hold throughout // the pool's lifetime, as pools with mutable tokens can append and remove tokens in any order. uint256 tokensLength = tokens.length; for (uint256 i = 0; i < tokensLength; i++) { if (tokens[i] == token) { return i; } } _revert(Errors.INVALID_TOKEN); } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // solhint-disable // To simplify Pool logic, all token balances and amounts are normalized to behave as if the token had 18 decimals. // e.g. When comparing DAI (18 decimals) and USDC (6 decimals), 1 USDC and 1 DAI would both be represented as 1e18, // whereas without scaling 1 USDC would be represented as 1e6. // This allows us to not consider differences in token decimals in the internal Pool maths, simplifying it greatly. // Single Value /** * @dev Applies `scalingFactor` to `amount`, resulting in a larger or equal value depending on whether it needed * scaling or not. */ function _upscale(uint256 amount, uint256 scalingFactor) pure returns (uint256) { // Upscale rounding wouldn't necessarily always go in the same direction: in a swap for example the balance of // token in should be rounded up, and that of token out rounded down. This is the only place where we round in // the same direction for all amounts, as the impact of this rounding is expected to be minimal. return FixedPoint.mulDown(amount, scalingFactor); } /** * @dev Reverses the `scalingFactor` applied to `amount`, resulting in a smaller or equal value depending on * whether it needed scaling or not. The result is rounded down. */ function _downscaleDown(uint256 amount, uint256 scalingFactor) pure returns (uint256) { return FixedPoint.divDown(amount, scalingFactor); } /** * @dev Reverses the `scalingFactor` applied to `amount`, resulting in a smaller or equal value depending on * whether it needed scaling or not. The result is rounded up. */ function _downscaleUp(uint256 amount, uint256 scalingFactor) pure returns (uint256) { return FixedPoint.divUp(amount, scalingFactor); } // Array /** * @dev Same as `_upscale`, but for an entire array. This function does not return anything, but instead *mutates* * the `amounts` array. */ function _upscaleArray(uint256[] memory amounts, uint256[] memory scalingFactors) pure { uint256 length = amounts.length; InputHelpers.ensureInputLengthMatch(length, scalingFactors.length); for (uint256 i = 0; i < length; ++i) { amounts[i] = FixedPoint.mulDown(amounts[i], scalingFactors[i]); } } /** * @dev Same as `_downscaleDown`, but for an entire array. This function does not return anything, but instead * *mutates* the `amounts` array. */ function _downscaleDownArray(uint256[] memory amounts, uint256[] memory scalingFactors) pure { uint256 length = amounts.length; InputHelpers.ensureInputLengthMatch(length, scalingFactors.length); for (uint256 i = 0; i < length; ++i) { amounts[i] = FixedPoint.divDown(amounts[i], scalingFactors[i]); } } /** * @dev Same as `_downscaleUp`, but for an entire array. This function does not return anything, but instead * *mutates* the `amounts` array. */ function _downscaleUpArray(uint256[] memory amounts, uint256[] memory scalingFactors) pure { uint256 length = amounts.length; InputHelpers.ensureInputLengthMatch(length, scalingFactors.length); for (uint256 i = 0; i < length; ++i) { amounts[i] = FixedPoint.divUp(amounts[i], scalingFactors[i]); } } function _computeScalingFactor(IERC20 token) view returns (uint256) { // Tokens that don't implement the `decimals` method are not supported. uint256 tokenDecimals = ERC20(address(token)).decimals(); // Tokens with more than 18 decimals are not supported. uint256 decimalsDifference = Math.sub(18, tokenDecimals); return FixedPoint.ONE * 10**decimalsDifference; } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @dev Library for encoding and decoding values stored inside a 256 bit word. Typically used to pack multiple values in * a single storage slot, saving gas by performing less storage accesses. * * Each value is defined by its size and the least significant bit in the word, also known as offset. For example, two * 128 bit values may be encoded in a word by assigning one an offset of 0, and the other an offset of 128. * * We could use Solidity structs to pack values together in a single storage slot instead of relying on a custom and * error-prone library, but unfortunately Solidity only allows for structs to live in either storage, calldata or * memory. Because a memory struct uses not just memory but also a slot in the stack (to store its memory location), * using memory for word-sized values (i.e. of 256 bits or less) is strictly less gas performant, and doesn't even * prevent stack-too-deep issues. This is compounded by the fact that Balancer contracts typically are memory-intensive, * and the cost of accesing memory increases quadratically with the number of allocated words. Manual packing and * unpacking is therefore the preferred approach. */ library WordCodec { // solhint-disable no-inline-assembly // Masks are values with the least significant N bits set. They can be used to extract an encoded value from a word, // or to insert a new one replacing the old. uint256 private constant _MASK_1 = 2**(1) - 1; uint256 private constant _MASK_192 = 2**(192) - 1; // In-place insertion /** * @dev Inserts an unsigned integer of bitLength, shifted by an offset, into a 256 bit word, * replacing the old value. Returns the new word. */ function insertUint( bytes32 word, uint256 value, uint256 offset, uint256 bitLength ) internal pure returns (bytes32 result) { _validateEncodingParams(value, offset, bitLength); // Equivalent to: // uint256 mask = (1 << bitLength) - 1; // bytes32 clearedWord = bytes32(uint256(word) & ~(mask << offset)); // result = clearedWord | bytes32(value << offset); assembly { let mask := sub(shl(bitLength, 1), 1) let clearedWord := and(word, not(shl(offset, mask))) result := or(clearedWord, shl(offset, value)) } } /** * @dev Inserts a signed integer shifted by an offset into a 256 bit word, replacing the old value. Returns * the new word. * * Assumes `value` can be represented using `bitLength` bits. */ function insertInt( bytes32 word, int256 value, uint256 offset, uint256 bitLength ) internal pure returns (bytes32) { _validateEncodingParams(value, offset, bitLength); uint256 mask = (1 << bitLength) - 1; bytes32 clearedWord = bytes32(uint256(word) & ~(mask << offset)); // Integer values need masking to remove the upper bits of negative values. return clearedWord | bytes32((uint256(value) & mask) << offset); } // Encoding /** * @dev Encodes an unsigned integer shifted by an offset. Ensures value fits within * `bitLength` bits. * * The return value can be ORed bitwise with other encoded values to form a 256 bit word. */ function encodeUint( uint256 value, uint256 offset, uint256 bitLength ) internal pure returns (bytes32) { _validateEncodingParams(value, offset, bitLength); return bytes32(value << offset); } /** * @dev Encodes a signed integer shifted by an offset. * * The return value can be ORed bitwise with other encoded values to form a 256 bit word. */ function encodeInt( int256 value, uint256 offset, uint256 bitLength ) internal pure returns (bytes32) { _validateEncodingParams(value, offset, bitLength); uint256 mask = (1 << bitLength) - 1; // Integer values need masking to remove the upper bits of negative values. return bytes32((uint256(value) & mask) << offset); } // Decoding /** * @dev Decodes and returns an unsigned integer with `bitLength` bits, shifted by an offset, from a 256 bit word. */ function decodeUint( bytes32 word, uint256 offset, uint256 bitLength ) internal pure returns (uint256 result) { // Equivalent to: // result = uint256(word >> offset) & ((1 << bitLength) - 1); assembly { result := and(shr(offset, word), sub(shl(bitLength, 1), 1)) } } /** * @dev Decodes and returns a signed integer with `bitLength` bits, shifted by an offset, from a 256 bit word. */ function decodeInt( bytes32 word, uint256 offset, uint256 bitLength ) internal pure returns (int256 result) { int256 maxInt = int256((1 << (bitLength - 1)) - 1); uint256 mask = (1 << bitLength) - 1; int256 value = int256(uint256(word >> offset) & mask); // In case the decoded value is greater than the max positive integer that can be represented with bitLength // bits, we know it was originally a negative integer. Therefore, we mask it to restore the sign in the 256 bit // representation. // // Equivalent to: // result = value > maxInt ? (value | int256(~mask)) : value; assembly { result := or(mul(gt(value, maxInt), not(mask)), value) } } // Special cases /** * @dev Decodes and returns a boolean shifted by an offset from a 256 bit word. */ function decodeBool(bytes32 word, uint256 offset) internal pure returns (bool result) { // Equivalent to: // result = (uint256(word >> offset) & 1) == 1; assembly { result := and(shr(offset, word), 1) } } /** * @dev Inserts a 192 bit value shifted by an offset into a 256 bit word, replacing the old value. * Returns the new word. * * Assumes `value` can be represented using 192 bits. */ function insertBits192( bytes32 word, bytes32 value, uint256 offset ) internal pure returns (bytes32) { bytes32 clearedWord = bytes32(uint256(word) & ~(_MASK_192 << offset)); return clearedWord | bytes32((uint256(value) & _MASK_192) << offset); } /** * @dev Inserts a boolean value shifted by an offset into a 256 bit word, replacing the old value. Returns the new * word. */ function insertBool( bytes32 word, bool value, uint256 offset ) internal pure returns (bytes32 result) { // Equivalent to: // bytes32 clearedWord = bytes32(uint256(word) & ~(1 << offset)); // bytes32 referenceInsertBool = clearedWord | bytes32(uint256(value ? 1 : 0) << offset); assembly { let clearedWord := and(word, not(shl(offset, 1))) result := or(clearedWord, shl(offset, value)) } } // Helpers function _validateEncodingParams( uint256 value, uint256 offset, uint256 bitLength ) private pure { _require(offset < 256, Errors.OUT_OF_BOUNDS); // We never accept 256 bit values (which would make the codec pointless), and the larger the offset the smaller // the maximum bit length. _require(bitLength >= 1 && bitLength <= Math.min(255, 256 - offset), Errors.OUT_OF_BOUNDS); // Testing unsigned values for size is straightforward: their upper bits must be cleared. _require(value >> bitLength == 0, Errors.CODEC_OVERFLOW); } function _validateEncodingParams( int256 value, uint256 offset, uint256 bitLength ) private pure { _require(offset < 256, Errors.OUT_OF_BOUNDS); // We never accept 256 bit values (which would make the codec pointless), and the larger the offset the smaller // the maximum bit length. _require(bitLength >= 1 && bitLength <= Math.min(255, 256 - offset), Errors.OUT_OF_BOUNDS); // Testing signed values for size is a bit more involved. if (value >= 0) { // For positive values, we can simply check that the upper bits are clear. Notice we remove one bit from the // length for the sign bit. _require(value >> (bitLength - 1) == 0, Errors.CODEC_OVERFLOW); } else { // Negative values can receive the same treatment by making them positive, with the caveat that the range // for negative values in two's complement supports one more value than for the positive case. _require(Math.abs(value + 1) >> (bitLength - 1) == 0, Errors.CODEC_OVERFLOW); } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library ExternalFees { using FixedPoint for uint256; /** * @dev Calculates the amount of BPT necessary to give ownership of a given percentage of the Pool to an external * third party. In the case of protocol fees, this is the DAO, but could also be a pool manager, etc. * Note that this function reverts if `poolPercentage` >= 100%, it's expected that the caller will enforce this. * @param totalSupply - The total supply of the pool prior to minting BPT. * @param poolOwnershipPercentage - The desired ownership percentage of the pool to have as a result of minting BPT. * @return bptAmount - The amount of BPT to mint such that it is `poolPercentage` of the resultant total supply. */ function bptForPoolOwnershipPercentage(uint256 totalSupply, uint256 poolOwnershipPercentage) internal pure returns (uint256) { // If we mint some amount `bptAmount` of BPT then the percentage ownership of the pool this grants is given by: // `poolOwnershipPercentage = bptAmount / (totalSupply + bptAmount)`. // Solving for `bptAmount`, we arrive at: // `bptAmount = totalSupply * poolOwnershipPercentage / (1 - poolOwnershipPercentage)`. return Math.divDown(Math.mul(totalSupply, poolOwnershipPercentage), poolOwnershipPercentage.complement()); } } library InvariantGrowthProtocolSwapFees { using FixedPoint for uint256; function getProtocolOwnershipPercentage( uint256 invariantGrowthRatio, uint256 supplyGrowthRatio, uint256 protocolSwapFeePercentage ) internal pure returns (uint256) { // Joins and exits are symmetrical; for simplicity, we consider a join, where the invariant and supply // both increase. // |-------------------------|-- original invariant * invariantGrowthRatio // | increase from fees | // |-------------------------|-- original invariant * supply growth ratio (fee-less invariant) // | | // | increase from balances | // |-------------------------|-- original invariant // | | // | | |------------------|-- currentSupply // | | | BPT minted | // | | |------------------|-- previousSupply // | original invariant | | original supply | // |_________________________| |__________________| // // If the join is proportional, the invariant and supply will likewise increase proportionally, // so the growth ratios (invariantGrowthRatio / supplyGrowthRatio) will be equal. In this case, we do not charge // any protocol fees. // We also charge no protocol fees in the case where `invariantGrowthRatio < supplyGrowthRatio` to avoid // potential underflows, however this should only occur in extremely low volume actions due solely to rounding // error. if ((supplyGrowthRatio >= invariantGrowthRatio) || (protocolSwapFeePercentage == 0)) return 0; // If the join is non-proportional, the supply increase will be proportionally less than the invariant increase, // since the BPT minted will be based on fewer tokens (because swap fees are not included). So the supply growth // is due entirely to the balance changes, while the invariant growth also includes swap fees. // // To isolate the amount of increase by fees then, we multiply the original invariant by the supply growth // ratio to get the "feeless invariant". The difference between the final invariant and this value is then // the amount of the invariant due to fees, which we convert to a percentage by normalizing against the // final invariant. This is expressed as the expression below: // // invariantGrowthFromFees = currentInvariant - supplyGrowthRatio * previousInvariant // // We then divide through by current invariant so the LHS can be identified as the fraction of the pool which // is made up of accumulated swap fees. // // swapFeesPercentage = 1 - supplyGrowthRatio * previousInvariant / currentInvariant // // We then define `invariantGrowthRatio` in a similar fashion to `supplyGrowthRatio` to give the result: // // swapFeesPercentage = 1 - supplyGrowthRatio / invariantGrowthRatio // // Using this form allows us to consider only the ratios of the two invariants, rather than their absolute // values: a useful property, as this is sometimes easier than calculating the full invariant twice. // We've already checked that `supplyGrowthRatio` is smaller than `invariantGrowthRatio`, and hence their ratio // smaller than FixedPoint.ONE, allowing for unchecked arithmetic. uint256 swapFeesPercentage = FixedPoint.ONE - supplyGrowthRatio.divDown(invariantGrowthRatio); // We then multiply by the protocol swap fee percentage to get the fraction of the pool which the protocol // should own once fees have been collected. return swapFeesPercentage.mulDown(protocolSwapFeePercentage); } function calcDueProtocolFees( uint256 invariantGrowthRatio, uint256 previousSupply, uint256 currentSupply, uint256 protocolSwapFeePercentage ) internal pure returns (uint256) { uint256 protocolOwnershipPercentage = getProtocolOwnershipPercentage( invariantGrowthRatio, currentSupply.divDown(previousSupply), protocolSwapFeePercentage ); return ExternalFees.bptForPoolOwnershipPercentage(currentSupply, protocolOwnershipPercentage); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @dev Base authorization layer implementation for Pools. * * The owner account can call some of the permissioned functions - access control of the rest is delegated to the * Authorizer. Note that this owner is immutable: more sophisticated permission schemes, such as multiple ownership, * granular roles, etc., could be built on top of this by making the owner a smart contract. * * Access control of all other permissioned functions is delegated to an Authorizer. It is also possible to delegate * control of *all* permissioned functions to the Authorizer by setting the owner address to `_DELEGATE_OWNER`. */ abstract contract BasePoolAuthorization is Authentication { address private immutable _owner; address internal constant _DELEGATE_OWNER = 0xBA1BA1ba1BA1bA1bA1Ba1BA1ba1BA1bA1ba1ba1B; constructor(address owner) { _owner = owner; } function getOwner() public view returns (address) { return _owner; } function getAuthorizer() external view returns (IAuthorizer) { return _getAuthorizer(); } function _canPerform(bytes32 actionId, address account) internal view override returns (bool) { if ((getOwner() != _DELEGATE_OWNER) && _isOwnerOnlyAction(actionId)) { // Only the owner can perform "owner only" actions, unless the owner is delegated. return msg.sender == getOwner(); } else { // Non-owner actions are always processed via the Authorizer, as "owner only" ones are when delegated. return _getAuthorizer().canPerform(actionId, account, address(this)); } } function _isOwnerOnlyAction(bytes32) internal view virtual returns (bool) { return false; } function _getAuthorizer() internal view virtual returns (IAuthorizer); } /** * @dev Interface for the RecoveryMode module. */ interface IRecoveryMode { /** * @dev Emitted when the Recovery Mode status changes. */ event RecoveryModeStateChanged(bool enabled); /** * @notice Enables Recovery Mode in the Pool, disabling protocol fee collection and allowing for safe proportional * exits with low computational complexity and no dependencies. */ function enableRecoveryMode() external; /** * @notice Disables Recovery Mode in the Pool, restoring protocol fee collection and disallowing proportional exits. */ function disableRecoveryMode() external; /** * @notice Returns true if the Pool is in Recovery Mode. */ function inRecoveryMode() external view returns (bool); } library BasePoolUserData { // Special ExitKind for all pools, used in Recovery Mode. Use the max 8-bit value to prevent conflicts // with future additions to the ExitKind enums (or any front-end code that maps to existing values) uint8 public constant RECOVERY_MODE_EXIT_KIND = 255; // Return true if this is the special exit kind. function isRecoveryModeExitKind(bytes memory self) internal pure returns (bool) { // Check for the "no data" case, or abi.decode would revert return self.length > 0 && abi.decode(self, (uint8)) == RECOVERY_MODE_EXIT_KIND; } // Parse the bptAmountIn out of the userData function recoveryModeExit(bytes memory self) internal pure returns (uint256 bptAmountIn) { (, bptAmountIn) = abi.decode(self, (uint8, uint256)); } } /** * @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)); } // solc-ignore-next-line func-mutability function _getChainId() private view returns (uint256 chainId) { // solhint-disable-next-line no-inline-assembly assembly { chainId := chainid() } } } /** * @dev Utility for signing Solidity function calls. */ abstract contract EOASignaturesValidator is ISignaturesValidator, EIP712 { // Replay attack prevention for each account. mapping(address => uint256) internal _nextNonce; function getDomainSeparator() public view override returns (bytes32) { return _domainSeparatorV4(); } function getNextNonce(address account) public view override returns (uint256) { return _nextNonce[account]; } function _ensureValidSignature( address account, bytes32 structHash, bytes memory signature, uint256 errorCode ) internal { return _ensureValidSignature(account, structHash, signature, type(uint256).max, errorCode); } function _ensureValidSignature( address account, bytes32 structHash, bytes memory signature, uint256 deadline, uint256 errorCode ) internal { bytes32 digest = _hashTypedDataV4(structHash); _require(_isValidSignature(account, digest, signature), errorCode); // We could check for the deadline before validating the signature, but this leads to saner error processing (as // we only care about expired deadlines if the signature is correct) and only affects the gas cost of the revert // scenario, which will only occur infrequently, if ever. // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy. // solhint-disable-next-line not-rely-on-time _require(deadline >= block.timestamp, Errors.EXPIRED_SIGNATURE); // We only advance the nonce after validating the signature. This is irrelevant for this module, but it can be // important in derived contracts that override _isValidSignature (e.g. SignaturesValidator), as we want for // the observable state to still have the current nonce as the next valid one. _nextNonce[account] += 1; } function _isValidSignature( address account, bytes32 digest, bytes memory signature ) internal view virtual returns (bool) { _require(signature.length == 65, Errors.MALFORMED_SIGNATURE); bytes32 r; bytes32 s; uint8 v; // ecrecover takes the r, s and v signature parameters, and the only way to get them is to use assembly. // solhint-disable-next-line no-inline-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } 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 == account); } function _toArraySignature( uint8 v, bytes32 r, bytes32 s ) internal pure returns (bytes memory) { bytes memory signature = new bytes(65); // solhint-disable-next-line no-inline-assembly assembly { mstore(add(signature, 32), r) mstore(add(signature, 64), s) mstore8(add(signature, 96), v) } return signature; } } /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens, * given `owner`'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } /** * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. * * _Available since v3.4._ */ abstract contract ERC20Permit is ERC20, IERC20Permit, EOASignaturesValidator { // solhint-disable-next-line var-name-mixedcase bytes32 private constant _PERMIT_TYPEHASH = keccak256( "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)" ); /** * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`. * * It's a good idea to use the same `name` that is defined as the ERC20 token name. */ constructor(string memory name) EIP712(name, "1") { // solhint-disable-previous-line no-empty-blocks } /** * @dev See {IERC20Permit-permit}. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual override { bytes32 structHash = keccak256( abi.encode(_PERMIT_TYPEHASH, owner, spender, value, getNextNonce(owner), deadline) ); _ensureValidSignature(owner, structHash, _toArraySignature(v, r, s), deadline, Errors.INVALID_SIGNATURE); _approve(owner, spender, value); } /** * @dev See {IERC20Permit-nonces}. */ function nonces(address owner) public view override returns (uint256) { return getNextNonce(owner); } /** * @dev See {IERC20Permit-DOMAIN_SEPARATOR}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view override returns (bytes32) { return getDomainSeparator(); } } /** * @notice Handle storage and state changes for pools that support "Recovery Mode". * * @dev This is intended to provide a safe way to exit any pool during some kind of emergency, to avoid locking funds * in the event the pool enters a non-functional state (i.e., some code that normally runs during exits is causing * them to revert). * * Recovery Mode is *not* the same as pausing the pool. The pause function is only available during a short window * after factory deployment. Pausing can only be intentionally reversed during a buffer period, and the contract * will permanently unpause itself thereafter. Paused pools are completely disabled, in a kind of suspended animation, * until they are voluntarily or involuntarily unpaused. * * By contrast, a privileged account - typically a governance multisig - can place a pool in Recovery Mode at any * time, and it is always reversible. The pool is *not* disabled while in this mode: though of course whatever * condition prompted the transition to Recovery Mode has likely effectively disabled some functions. Rather, * a special "clean" exit is enabled, which runs the absolute minimum code necessary to exit proportionally. * In particular, stable pools do not attempt to compute the invariant (which is a complex, iterative calculation * that can fail in extreme circumstances), and no protocol fees are collected. * * It is critical to ensure that turning on Recovery Mode would do no harm, if activated maliciously or in error. */ abstract contract RecoveryMode is IRecoveryMode, BasePoolAuthorization { using FixedPoint for uint256; using BasePoolUserData for bytes; /** * @dev Reverts if the contract is in Recovery Mode. */ modifier whenNotInRecoveryMode() { _ensureNotInRecoveryMode(); _; } /** * @notice Enable recovery mode, which enables a special safe exit path for LPs. * @dev Does not otherwise affect pool operations (beyond deferring payment of protocol fees), though some pools may * perform certain operations in a "safer" manner that is less likely to fail, in an attempt to keep the pool * running, even in a pathological state. Unlike the Pause operation, which is only available during a short window * after factory deployment, Recovery Mode can always be enabled. */ function enableRecoveryMode() external override authenticate { // Unlike when recovery mode is disabled, derived contracts should *not* do anything when it is enabled. // We do not want to make any calls that could fail and prevent the pool from entering recovery mode. // Accordingly, this should have no effect, but for consistency with `disableRecoveryMode`, revert if // recovery mode was already enabled. _ensureNotInRecoveryMode(); _setRecoveryMode(true); emit RecoveryModeStateChanged(true); } /** * @notice Disable recovery mode, which disables the special safe exit path for LPs. * @dev Protocol fees are not paid while in Recovery Mode, so it should only remain active for as long as strictly * necessary. */ function disableRecoveryMode() external override authenticate { // Some derived contracts respond to disabling recovery mode with state changes (e.g., related to protocol fees, // or otherwise ensuring that enabling and disabling recovery mode has no ill effects on LPs). When called // outside of recovery mode, these state changes might lead to unexpected behavior. _ensureInRecoveryMode(); _setRecoveryMode(false); emit RecoveryModeStateChanged(false); } // Defer implementation for functions that require storage /** * @notice Override to check storage and return whether the pool is in Recovery Mode */ function inRecoveryMode() public view virtual override returns (bool); /** * @dev Override to update storage and emit the event * * No complex code or external calls that could fail should be placed in the implementations, * which could jeopardize the ability to enable and disable Recovery Mode. */ function _setRecoveryMode(bool enabled) internal virtual; /** * @dev Reverts if the contract is not in Recovery Mode. */ function _ensureInRecoveryMode() internal view { _require(inRecoveryMode(), Errors.NOT_IN_RECOVERY_MODE); } /** * @dev Reverts if the contract is in Recovery Mode. */ function _ensureNotInRecoveryMode() internal view { _require(!inRecoveryMode(), Errors.IN_RECOVERY_MODE); } /** * @dev A minimal proportional exit, suitable as is for most pools: though not for pools with preminted BPT * or other special considerations. Designed to be overridden if a pool needs to do extra processing, * such as scaling a stored invariant, or caching the new total supply. * * No complex code or external calls should be made in derived contracts that override this! */ function _doRecoveryModeExit( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) internal virtual returns (uint256, uint256[] memory); } /** * @dev The Vault does not provide the protocol swap fee percentage in swap hooks (as swaps don't typically need this * value), so for swaps that need this value, we would have to to fetch it ourselves from the * ProtocolFeePercentagesProvider. Additionally, other protocol fee types (such as Yield or AUM) can only be obtained * by making said call. * * However, these values change so rarely that it doesn't make sense to perform the required calls to get the current * values in every single user interaction. Instead, we keep a local copy that can be permissionlessly updated by anyone * with the real value. We also pack these values together, performing a single storage read to get them all. */ abstract contract ProtocolFeeCache is RecoveryMode { using SafeCast for uint256; using WordCodec for bytes32; // Protocol Fee IDs represent fee types; we are supporting 3 types (join, yield and aum), so 8 bits is enough to // store each of them. // [ 232 bits | 8 bits | 8 bits | 8 bits ] // [ unused | AUM fee ID | Yield fee ID | Swap fee ID ] // [MSB LSB] uint256 private constant _FEE_TYPE_ID_WIDTH = 8; uint256 private constant _SWAP_FEE_ID_OFFSET = 0; uint256 private constant _YIELD_FEE_ID_OFFSET = _SWAP_FEE_ID_OFFSET + _FEE_TYPE_ID_WIDTH; uint256 private constant _AUM_FEE_ID_OFFSET = _YIELD_FEE_ID_OFFSET + _FEE_TYPE_ID_WIDTH; // Protocol Fee Percentages can never be larger than 100% (1e18), which fits in ~59 bits, so using 64 for each type // is sufficient. // [ 64 bits | 64 bits | 64 bits | 64 bits ] // [ unused | AUM fee cache | Yield fee cache | Swap fee cache ] // [MSB LSB] uint256 private constant _FEE_TYPE_CACHE_WIDTH = 64; uint256 private constant _SWAP_FEE_OFFSET = 0; uint256 private constant _YIELD_FEE_OFFSET = _SWAP_FEE_OFFSET + _FEE_TYPE_CACHE_WIDTH; uint256 private constant _AUM_FEE_OFFSET = _YIELD_FEE_OFFSET + _FEE_TYPE_CACHE_WIDTH; event ProtocolFeePercentageCacheUpdated(bytes32 feeCache); /** * @dev Protocol fee types can be set at contract creation. Fee IDs store which of the IDs in the protocol fee * provider shall be applied to its respective fee type (swap, yield, aum). * This is because some Pools may have different protocol fee values for the same type of underlying operation: * for example, Stable Pools might have a different swap protocol fee than Weighted Pools. * This module does not check at all that the chosen fee types have any sort of relation with the operation they're * assigned to: it is possible to e.g. set a Pool's swap protocol fee to equal the flash loan protocol fee. */ struct ProviderFeeIDs { uint256 swap; uint256 yield; uint256 aum; } IProtocolFeePercentagesProvider private immutable _protocolFeeProvider; bytes32 private immutable _feeIds; bytes32 private _feeCache; constructor(IProtocolFeePercentagesProvider protocolFeeProvider, ProviderFeeIDs memory providerFeeIDs) { _protocolFeeProvider = protocolFeeProvider; bytes32 feeIds = WordCodec.encodeUint(providerFeeIDs.swap, _SWAP_FEE_ID_OFFSET, _FEE_TYPE_ID_WIDTH) | WordCodec.encodeUint(providerFeeIDs.yield, _YIELD_FEE_ID_OFFSET, _FEE_TYPE_ID_WIDTH) | WordCodec.encodeUint(providerFeeIDs.aum, _AUM_FEE_ID_OFFSET, _FEE_TYPE_ID_WIDTH); _feeIds = feeIds; _updateProtocolFeeCache(protocolFeeProvider, feeIds); } /** * @notice Returns the cached protocol fee percentage. */ function getProtocolFeePercentageCache(uint256 feeType) public view returns (uint256) { if (inRecoveryMode()) { return 0; } uint256 offset; if (feeType == ProtocolFeeType.SWAP) { offset = _SWAP_FEE_OFFSET; } else if (feeType == ProtocolFeeType.YIELD) { offset = _YIELD_FEE_OFFSET; } else if (feeType == ProtocolFeeType.AUM) { offset = _AUM_FEE_OFFSET; } else { _revert(Errors.UNHANDLED_FEE_TYPE); } return _feeCache.decodeUint(offset, _FEE_TYPE_CACHE_WIDTH); } /** * @notice Returns the provider fee ID for the given fee type. */ function getProviderFeeId(uint256 feeType) public view returns (uint256) { uint256 offset; if (feeType == ProtocolFeeType.SWAP) { offset = _SWAP_FEE_ID_OFFSET; } else if (feeType == ProtocolFeeType.YIELD) { offset = _YIELD_FEE_ID_OFFSET; } else if (feeType == ProtocolFeeType.AUM) { offset = _AUM_FEE_ID_OFFSET; } else { _revert(Errors.UNHANDLED_FEE_TYPE); } return _feeIds.decodeUint(offset, _FEE_TYPE_ID_WIDTH); } /** * @notice Updates the cache to the latest value set by governance. * @dev Can be called by anyone to update the cached fee percentages. */ function updateProtocolFeePercentageCache() external { _beforeProtocolFeeCacheUpdate(); _updateProtocolFeeCache(_protocolFeeProvider, _feeIds); } /** * @dev Override in derived contracts to perform some action before the cache is updated. This is typically relevant * to Pools that incur protocol debt between operations. To avoid altering the amount due retroactively, this debt * needs to be paid before the fee percentages change. */ function _beforeProtocolFeeCacheUpdate() internal virtual { // solhint-disable-previous-line no-empty-blocks } function _updateProtocolFeeCache(IProtocolFeePercentagesProvider protocolFeeProvider, bytes32 feeIds) private { uint256 swapFee = protocolFeeProvider.getFeeTypePercentage( feeIds.decodeUint(_SWAP_FEE_ID_OFFSET, _FEE_TYPE_ID_WIDTH) ); uint256 yieldFee = protocolFeeProvider.getFeeTypePercentage( feeIds.decodeUint(_YIELD_FEE_ID_OFFSET, _FEE_TYPE_ID_WIDTH) ); uint256 aumFee = protocolFeeProvider.getFeeTypePercentage( feeIds.decodeUint(_AUM_FEE_ID_OFFSET, _FEE_TYPE_ID_WIDTH) ); bytes32 feeCache = WordCodec.encodeUint(swapFee, _SWAP_FEE_OFFSET, _FEE_TYPE_CACHE_WIDTH) | WordCodec.encodeUint(yieldFee, _YIELD_FEE_OFFSET, _FEE_TYPE_CACHE_WIDTH) | WordCodec.encodeUint(aumFee, _AUM_FEE_OFFSET, _FEE_TYPE_CACHE_WIDTH); _feeCache = feeCache; emit ProtocolFeePercentageCacheUpdated(feeCache); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library ExternalAUMFees { /** * @notice Calculates the amount of BPT to mint to pay AUM fees accrued since the last collection. * @dev This calculation assumes that the Pool's total supply is constant over the fee period. * * When paying AUM fees over short durations, significant rounding errors can be introduced when converting from a * percentage of the pool to a BPT amount. To combat this, we convert the yearly percentage to BPT and then scale * appropriately. */ function getAumFeesBptAmount( uint256 totalSupply, uint256 currentTime, uint256 lastCollection, uint256 annualAumFeePercentage ) internal pure returns (uint256) { // If no time has passed since the last collection then clearly no fees are accrued so we can return early. // We also perform an early return if the AUM fee is zero. if (currentTime <= lastCollection || annualAumFeePercentage == 0) return 0; uint256 annualBptAmount = ExternalFees.bptForPoolOwnershipPercentage(totalSupply, annualAumFeePercentage); // We want to collect fees so that after a year the Pool will have paid `annualAumFeePercentage` of its AUM as // fees. In normal operation however, we will collect fees regularly over the course of the year so we // multiply `annualBptAmount` by the fraction of the year which has elapsed since we last collected fees. uint256 elapsedTime = currentTime - lastCollection; // As an example for this calculate, consider a pool with a total supply of 1000e18 BPT, AUM fees are charged // at 5% yearly and it's been 7 days since the last collection of AUM fees. The expected fees are then: // // expected_yearly_fees = totalSupply * annualAumFeePercentage / (1 - annualAumFeePercentage) // = 1000e18 * 0.05 / 0.95 // ~= 52.63e18 BPT // // fees_to_collect = expected_yearly_fees * time_since_last_collection / 1 year // = 52.63e18 * 7 / 365 // ~= 1.009 BPT // // Note that if we were to mint expected_yearly_fees BPT then the recipient would own 52.63e18 out of // 1052.63e18 BPT. This agrees with the recipient being expected to own 5% of the Pool *after* fees are paid. // Like with all other fees, we round down, favoring LPs. return Math.divDown(Math.mul(annualBptAmount, elapsedTime), 365 days); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @title Highly opinionated token implementation * @author Balancer Labs * @dev * - Includes functions to increase and decrease allowance as a workaround * for the well-known issue with `approve`: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * - Allows for 'infinite allowance', where an allowance of 0xff..ff is not * decreased by calls to transferFrom * - Lets a token holder use `transferFrom` to send their own tokens, * without first setting allowance * - Emits 'Approval' events whenever allowance is changed by `transferFrom` * - Assigns infinite allowance for all token holders to the Vault */ contract BalancerPoolToken is ERC20Permit { IVault private immutable _vault; constructor( string memory tokenName, string memory tokenSymbol, IVault vault ) ERC20(tokenName, tokenSymbol) ERC20Permit(tokenName) { _vault = vault; } function getVault() public view returns (IVault) { return _vault; } // Overrides /** * @dev Override to grant the Vault infinite allowance, causing for Pool Tokens to not require approval. * * This is sound as the Vault already provides authorization mechanisms when initiation token transfers, which this * contract inherits. */ function allowance(address owner, address spender) public view override returns (uint256) { if (spender == address(getVault())) { return uint256(-1); } else { return super.allowance(owner, spender); } } /** * @dev Override to allow for 'infinite allowance' and let the token owner use `transferFrom` with no self-allowance */ function transferFrom( address sender, address recipient, uint256 amount ) public override returns (bool) { uint256 currentAllowance = allowance(sender, msg.sender); _require(msg.sender == sender || currentAllowance >= amount, Errors.ERC20_TRANSFER_EXCEEDS_ALLOWANCE); _transfer(sender, recipient, amount); if (msg.sender != sender && currentAllowance != uint256(-1)) { // Because of the previous require, we know that if msg.sender != sender then currentAllowance >= amount _approve(sender, msg.sender, currentAllowance - amount); } return true; } /** * @dev Override to allow decreasing allowance by more than the current amount (setting it to zero) */ function decreaseAllowance(address spender, uint256 amount) public override returns (bool) { uint256 currentAllowance = allowance(msg.sender, spender); if (amount >= currentAllowance) { _approve(msg.sender, spender, 0); } else { // No risk of underflow due to if condition _approve(msg.sender, spender, currentAllowance - amount); } return true; } // Internal functions function _mintPoolTokens(address recipient, uint256 amount) internal { _mint(recipient, amount); } function _burnPoolTokens(address sender, uint256 amount) internal { _burn(sender, amount); } } /** * @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); } /** * @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); } // solhint-disable max-states-count /** * @notice Reference implementation for the base layer of a Pool contract. * @dev Reference implementation for the base layer of a Pool contract that manages a single Pool with optional * Asset Managers, an admin-controlled swap fee percentage, and an emergency pause mechanism. * * This Pool pays protocol fees by minting BPT directly to the ProtocolFeeCollector instead of using the * `dueProtocolFees` return value. This results in the underlying tokens continuing to provide liquidity * for traders, while still keeping gas usage to a minimum since only a single token (the BPT) is transferred. * * Note that neither swap fees nor the pause mechanism are used by this contract. They are passed through so that * derived contracts can use them via the `_addSwapFeeAmount` and `_subtractSwapFeeAmount` functions, and the * `whenNotPaused` modifier. * * No admin permissions are checked here: instead, this contract delegates that to the Vault's own Authorizer. * * Because this contract doesn't implement the swap hooks, derived contracts should generally inherit from * BaseGeneralPool or BaseMinimalSwapInfoPool. Otherwise, subclasses must inherit from the corresponding interfaces * and implement the swap callbacks themselves. */ abstract contract NewBasePool is IBasePool, IGeneralPool, IMinimalSwapInfoPool, BasePoolAuthorization, BalancerPoolToken, TemporarilyPausable, RecoveryMode { using BasePoolUserData for bytes; uint256 private constant _DEFAULT_MINIMUM_BPT = 1e6; bytes32 private immutable _poolId; // Note that this value is immutable in the Vault, so we can make it immutable here and save gas IProtocolFeesCollector private immutable _protocolFeesCollector; constructor( IVault vault, bytes32 poolId, string memory name, string memory symbol, uint256 pauseWindowDuration, uint256 bufferPeriodDuration, address owner ) // Base Pools are expected to be deployed using factories. By using the factory address as the action // disambiguator, we make all Pools deployed by the same factory share action identifiers. This allows for // simpler management of permissions (such as being able to manage granting the 'set fee percentage' action in // any Pool created by the same factory), while still making action identifiers unique among different factories // if the selectors match, preventing accidental errors. Authentication(bytes32(uint256(msg.sender))) BalancerPoolToken(name, symbol, vault) BasePoolAuthorization(owner) TemporarilyPausable(pauseWindowDuration, bufferPeriodDuration) { // Set immutable state variables - these cannot be read from during construction _poolId = poolId; _protocolFeesCollector = vault.getProtocolFeesCollector(); } // Getters /** * @notice Return the pool id. */ function getPoolId() public view override returns (bytes32) { return _poolId; } function _getAuthorizer() internal view override returns (IAuthorizer) { // Access control management is delegated to the Vault's Authorizer. This lets Balancer Governance manage which // accounts can call permissioned functions: for example, to perform emergency pauses. // If the owner is delegated, then *all* permissioned functions, including `updateSwapFeeGradually`, will be // under Governance control. return getVault().getAuthorizer(); } /** * @dev Returns the minimum BPT supply. This amount is minted to the zero address during initialization, effectively * locking it. * * This is useful to make sure Pool initialization happens only once, but derived Pools can change this value (even * to zero) by overriding this function. */ function _getMinimumBpt() internal pure virtual returns (uint256) { return _DEFAULT_MINIMUM_BPT; } // Protocol Fees /** * @notice Return the ProtocolFeesCollector contract. * @dev This is immutable, and retrieved from the Vault on construction. (It is also immutable in the Vault.) */ function getProtocolFeesCollector() public view returns (IProtocolFeesCollector) { return _protocolFeesCollector; } /** * @dev Pays protocol fees by minting `bptAmount` to the Protocol Fee Collector. */ function _payProtocolFees(uint256 bptAmount) internal { if (bptAmount > 0) { _mintPoolTokens(address(getProtocolFeesCollector()), bptAmount); } } /** * @notice Pause the pool: an emergency action which disables all pool functions. * @dev This is a permissioned function that will only work during the Pause Window set during pool factory * deployment (see `TemporarilyPausable`). */ function pause() external authenticate { _setPaused(true); } /** * @notice Reverse a `pause` operation, and restore a pool to normal functionality. * @dev This is a permissioned function that will only work on a paused pool within the Buffer Period set during * pool factory deployment (see `TemporarilyPausable`). Note that any paused pools will automatically unpause * after the Buffer Period expires. */ function unpause() external authenticate { _setPaused(false); } modifier onlyVault(bytes32 poolId) { _require(msg.sender == address(getVault()), Errors.CALLER_NOT_VAULT); _require(poolId == getPoolId(), Errors.INVALID_POOL_ID); _; } // Swap / Join / Exit Hooks function onSwap( SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut ) external override onlyVault(request.poolId) returns (uint256) { _ensureNotPaused(); return _onSwapMinimal(request, balanceTokenIn, balanceTokenOut); } function _onSwapMinimal( SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut ) internal virtual returns (uint256); function onSwap( SwapRequest memory request, uint256[] memory balances, uint256 indexIn, uint256 indexOut ) external override onlyVault(request.poolId) returns (uint256) { _ensureNotPaused(); return _onSwapGeneral(request, balances, indexIn, indexOut); } function _onSwapGeneral( SwapRequest memory request, uint256[] memory balances, uint256 indexIn, uint256 indexOut ) internal virtual returns (uint256); /** * @notice Vault hook for adding liquidity to a pool (including the first time, "initializing" the pool). * @dev This function can only be called from the Vault, from `joinPool`. */ function onJoinPool( bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256, uint256, bytes memory userData ) external override onlyVault(poolId) returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFees) { uint256 bptAmountOut; _ensureNotPaused(); if (totalSupply() == 0) { (bptAmountOut, amountsIn) = _onInitializePool(sender, recipient, userData); // On initialization, we lock _getMinimumBpt() by minting it for the zero address. This BPT acts as a // minimum as it will never be burned, which reduces potential issues with rounding, and also prevents the // Pool from ever being fully drained. // Some pool types do not require this mechanism, and the minimum BPT might be zero. _require(bptAmountOut >= _getMinimumBpt(), Errors.MINIMUM_BPT); _mintPoolTokens(address(0), _getMinimumBpt()); _mintPoolTokens(recipient, bptAmountOut - _getMinimumBpt()); } else { (bptAmountOut, amountsIn) = _onJoinPool(sender, balances, userData); // Note we no longer use `balances` after calling `_onJoinPool`, which may mutate it. _mintPoolTokens(recipient, bptAmountOut); } // This Pool ignores the `dueProtocolFees` return value, so we simply return a zeroed-out array. dueProtocolFees = new uint256[](amountsIn.length); } /** * @notice Vault hook for removing liquidity from a pool. * @dev This function can only be called from the Vault, from `exitPool`. */ function onExitPool( bytes32 poolId, address sender, address, uint256[] memory balances, uint256, uint256, bytes memory userData ) external override onlyVault(poolId) returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFees) { uint256 bptAmountIn; // When a user calls `exitPool`, this is the first point of entry from the Vault. // We first check whether this is a Recovery Mode exit - if so, we proceed using this special lightweight exit // mechanism which avoids computing any complex values, interacting with external contracts, etc., and generally // should always work, even if the Pool's mathematics or a dependency break down. if (userData.isRecoveryModeExitKind()) { // This exit kind is only available in Recovery Mode. _ensureInRecoveryMode(); // Note that we don't upscale balances nor downscale amountsOut - we don't care about scaling factors during // a recovery mode exit. (bptAmountIn, amountsOut) = _doRecoveryModeExit(balances, totalSupply(), userData); } else { // Note that we only call this if we're not in a recovery mode exit. _ensureNotPaused(); (bptAmountIn, amountsOut) = _onExitPool(sender, balances, userData); } // Note we no longer use `balances` after calling `_onExitPool`, which may mutate it. _burnPoolTokens(sender, bptAmountIn); // This Pool ignores the `dueProtocolFees` return value, so we simply return a zeroed-out array. dueProtocolFees = new uint256[](amountsOut.length); } // Query functions /** * @notice "Dry run" `onJoinPool`. * @dev Returns the amount of BPT that would be granted to `recipient` if the `onJoinPool` hook were called by the * Vault with the same arguments, along with the number of tokens `sender` would have to supply. * * This function is not meant to be called directly, but rather from a helper contract that fetches current Vault * data, such as the protocol swap fee percentage and Pool balances. * * Like `IVault.queryBatchSwap`, this function is not view due to internal implementation details: the caller must * explicitly use eth_call instead of eth_sendTransaction. */ function queryJoin( bytes32, address sender, address, uint256[] memory balances, uint256, uint256, bytes memory userData ) external override returns (uint256 bptOut, uint256[] memory amountsIn) { _queryAction(sender, balances, userData, _onJoinPool); // The `return` opcode is executed directly inside `_queryAction`, so execution never reaches this statement, // and we don't need to return anything here - it just silences compiler warnings. return (bptOut, amountsIn); } /** * @notice "Dry run" `onExitPool`. * @dev Returns the amount of BPT that would be burned from `sender` if the `onExitPool` hook were called by the * Vault with the same arguments, along with the number of tokens `recipient` would receive. * * This function is not meant to be called directly, but rather from a helper contract that fetches current Vault * data, such as the protocol swap fee percentage and Pool balances. * * Like `IVault.queryBatchSwap`, this function is not view due to internal implementation details: the caller must * explicitly use eth_call instead of eth_sendTransaction. */ function queryExit( bytes32, address sender, address, uint256[] memory balances, uint256, uint256, bytes memory userData ) external override returns (uint256 bptIn, uint256[] memory amountsOut) { _queryAction(sender, balances, userData, _onExitPool); // The `return` opcode is executed directly inside `_queryAction`, so execution never reaches this statement, // and we don't need to return anything here - it just silences compiler warnings. return (bptIn, amountsOut); } // Internal hooks to be overridden by derived contracts - all token amounts (except BPT) in these interfaces are // upscaled. /** * @dev Called when the Pool is joined for the first time; that is, when the BPT total supply is zero. * * Returns the amount of BPT to mint, and the token amounts the Pool will receive in return. * * Minted BPT will be sent to `recipient`, except for _getMinimumBpt(), which will be deducted from this amount and * sent to the zero address instead. This will cause that BPT to remain forever locked there, preventing total BTP * from ever dropping below that value, and ensuring `_onInitializePool` can only be called once in the entire * Pool's lifetime. * * The tokens granted to the Pool will be transferred from `sender`. These amounts are considered upscaled and will * be downscaled (rounding up) before being returned to the Vault. */ function _onInitializePool( address sender, address recipient, bytes memory userData ) internal virtual returns (uint256 bptAmountOut, uint256[] memory amountsIn); /** * @dev Called whenever the Pool is joined after the first initialization join (see `_onInitializePool`). * * Returns the amount of BPT to mint, the token amounts that the Pool will receive in return, and the number of * tokens to pay in protocol swap fees. * * Implementations of this function might choose to mutate the `balances` array to save gas (e.g. when * performing intermediate calculations, such as subtraction of due protocol fees). This can be done safely. * * Minted BPT will be sent to `recipient`. * * The tokens granted to the Pool will be transferred from `sender`. These amounts are considered upscaled and will * be downscaled (rounding up) before being returned to the Vault. * * Due protocol swap fees will be taken from the Pool's balance in the Vault (see `IBasePool.onJoinPool`). These * amounts are considered upscaled and will be downscaled (rounding down) before being returned to the Vault. */ function _onJoinPool( address sender, uint256[] memory balances, bytes memory userData ) internal virtual returns (uint256 bptAmountOut, uint256[] memory amountsIn); /** * @dev Called whenever the Pool is exited. * * Returns the amount of BPT to burn, the token amounts for each Pool token that the Pool will grant in return, and * the number of tokens to pay in protocol swap fees. * * Implementations of this function might choose to mutate the `balances` array to save gas (e.g. when * performing intermediate calculations, such as subtraction of due protocol fees). This can be done safely. * * BPT will be burnt from `sender`. * * The Pool will grant tokens to `recipient`. These amounts are considered upscaled and will be downscaled * (rounding down) before being returned to the Vault. * * Due protocol swap fees will be taken from the Pool's balance in the Vault (see `IBasePool.onExitPool`). These * amounts are considered upscaled and will be downscaled (rounding down) before being returned to the Vault. */ function _onExitPool( address sender, uint256[] memory balances, bytes memory userData ) internal virtual returns (uint256 bptAmountIn, uint256[] memory amountsOut); function _queryAction( address sender, uint256[] memory balances, bytes memory userData, function(address, uint256[] memory, bytes memory) internal returns (uint256, uint256[] memory) _action ) private { // This uses the same technique used by the Vault in queryBatchSwap. Refer to that function for a detailed // explanation. 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 bpt and token amounts 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, 0x43adbafb00000000000000000000000000000000000000000000000000000000), 0) { returndatacopy(0, 0, returndatasize()) revert(0, returndatasize()) } // The returndata contains the signature, followed by the raw memory representation of the // `bptAmount` and `tokenAmounts` (array: length + data). We need to return an ABI-encoded // representation of these. // An ABI-encoded response will include one additional field to indicate the starting offset of // the `tokenAmounts` array. The `bptAmount` will be laid out in the first word of the // returndata. // // In returndata: // [ signature ][ bptAmount ][ tokenAmounts length ][ tokenAmounts values ] // [ 4 bytes ][ 32 bytes ][ 32 bytes ][ (32 * length) bytes ] // // We now need to return (ABI-encoded values): // [ bptAmount ][ tokeAmounts offset ][ tokenAmounts length ][ tokenAmounts values ] // [ 32 bytes ][ 32 bytes ][ 32 bytes ][ (32 * length) bytes ] // We copy 32 bytes for the `bptAmount` from returndata into memory. // Note that we skip the first 4 bytes for the error signature returndatacopy(0, 0x04, 32) // The offsets are 32-bytes long, so the array of `tokenAmounts` will start after // the initial 64 bytes. mstore(0x20, 64) // We now copy the raw memory array for the `tokenAmounts` from returndata into memory. // Since bpt amount and offset take up 64 bytes, we start copying at address 0x40. We also // skip the first 36 bytes from returndata, which correspond to the signature plus bpt amount. returndatacopy(0x40, 0x24, sub(returndatasize(), 36)) // We finally return the ABI-encoded uint256 and the array, which has a total length equal to // the size of returndata, plus the 32 bytes of the offset but without the 4 bytes of the // error signature. return(0, add(returndatasize(), 28)) } default { // This call should always revert, but we fail nonetheless if that didn't happen invalid() } } } else { (uint256 bptAmount, uint256[] memory tokenAmounts) = _action(sender, balances, userData); // solhint-disable-next-line no-inline-assembly assembly { // We will return a raw representation of `bptAmount` and `tokenAmounts` in memory, which is composed of // a 32-byte uint256, followed by a 32-byte for the array length, and finally the 32-byte uint256 values // Because revert expects a size in bytes, we multiply the array length (stored at `tokenAmounts`) by 32 let size := mul(mload(tokenAmounts), 32) // We store the `bptAmount` in the previous slot to the `tokenAmounts` array. We can make sure 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. let start := sub(tokenAmounts, 0x20) mstore(start, bptAmount) // We send one extra value for the error signature "QueryError(uint256,uint256[])" which is 0x43adbafb // We use the previous slot to `bptAmount`. mstore(sub(start, 0x20), 0x0000000000000000000000000000000000000000000000000000000043adbafb) start := sub(start, 0x04) // When copying from `tokenAmounts` into returndata, we copy the additional 68 bytes to also return // the `bptAmount`, the array 's length, and the error signature. revert(start, add(size, 68)) } } } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // solhint-disable not-rely-on-time library GradualValueChange { using FixedPoint for uint256; function getInterpolatedValue( uint256 startValue, uint256 endValue, uint256 startTime, uint256 endTime ) internal view returns (uint256) { uint256 pctProgress = calculateValueChangeProgress(startTime, endTime); return interpolateValue(startValue, endValue, pctProgress); } function resolveStartTime(uint256 startTime, uint256 endTime) internal view returns (uint256 resolvedStartTime) { // If the start time is in the past, "fast forward" to start now // This avoids discontinuities in the value curve. Otherwise, if you set the start/end times with // only 10% of the period in the future, the value would immediately jump 90% resolvedStartTime = Math.max(block.timestamp, startTime); _require(resolvedStartTime <= endTime, Errors.GRADUAL_UPDATE_TIME_TRAVEL); } function interpolateValue( uint256 startValue, uint256 endValue, uint256 pctProgress ) internal pure returns (uint256) { if (pctProgress >= FixedPoint.ONE || startValue == endValue) return endValue; if (pctProgress == 0) return startValue; if (startValue > endValue) { uint256 delta = pctProgress.mulDown(startValue - endValue); return startValue - delta; } else { uint256 delta = pctProgress.mulDown(endValue - startValue); return startValue + delta; } } /** * @dev Returns a fixed-point number representing how far along the current value change is, where 0 means the * change has not yet started, and FixedPoint.ONE means it has fully completed. */ function calculateValueChangeProgress(uint256 startTime, uint256 endTime) internal view returns (uint256) { if (block.timestamp >= endTime) { return FixedPoint.ONE; } else if (block.timestamp <= startTime) { return 0; } // No need for SafeMath as it was checked right above: endTime > block.timestamp > startTime uint256 totalSeconds = endTime - startTime; uint256 secondsElapsed = block.timestamp - startTime; // We don't need to consider zero division here as this is covered above. return secondsElapsed.divDown(totalSeconds); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @dev Library for compressing and decompressing numbers by using smaller types. * All values are 18 decimal fixed-point numbers, so heavier compression (fewer bits) * results in fewer decimals. */ library ValueCompression { /** * @notice Returns the maximum potential error when compressing and decompressing a value to a certain bit length. * @dev During compression, the range [0, maxUncompressedValue] is mapped onto the range [0, maxCompressedValue]. * Each increment in compressed space then corresponds to an increment of maxUncompressedValue / maxCompressedValue * in uncompressed space. This granularity is the maximum error when decompressing a compressed value. */ function maxCompressionError(uint256 bitLength, uint256 maxUncompressedValue) internal pure returns (uint256) { // It's not meaningful to compress 1-bit values (2 bits is also a bit silly, but theoretically possible). // 255 would likewise not be very helpful, but is technically valid. _require(bitLength >= 2 && bitLength <= 255, Errors.OUT_OF_BOUNDS); uint256 maxCompressedValue = (1 << bitLength) - 1; return Math.divUp(maxUncompressedValue, maxCompressedValue); } /** * @dev Compress a 256 bit value into `bitLength` bits. * To compress a value down to n bits, you first "normalize" it over the full input range. * For instance, if the maximum value were 10_000, and the `value` is 2_000, it would be * normalized to 0.2. * * Finally, "scale" that normalized value into the output range: adapting [0, maxUncompressedValue] * to [0, max n-bit value]. For n=8 bits, the max value is 255, so 0.2 corresponds to 51. * Likewise, for 16 bits, 0.2 would be stored as 13_107. */ function compress( uint256 value, uint256 bitLength, uint256 maxUncompressedValue ) internal pure returns (uint256) { // It's not meaningful to compress 1-bit values (2 bits is also a bit silly, but theoretically possible). // 255 would likewise not be very helpful, but is technically valid. _require(bitLength >= 2 && bitLength <= 255, Errors.OUT_OF_BOUNDS); // The value cannot exceed the input range, or the compression would not "fit" in the output range. _require(value <= maxUncompressedValue, Errors.OUT_OF_BOUNDS); // There is another way this can fail: maxUncompressedValue * value can overflow, if either or both // are too big. Essentially, the maximum bitLength will be about 256 - (# bits needed for maxUncompressedValue). // It's not worth it to test for this: the caller is responsible for many things anyway, notably ensuring // compress and decompress are called with the same arguments, and packing the resulting value properly // (the most common use is to assist in packing several variables into a 256-bit word). uint256 maxCompressedValue = (1 << bitLength) - 1; return Math.divDown(Math.mul(value, maxCompressedValue), maxUncompressedValue); } /** * @dev Reverse a compression operation, and restore the 256 bit value from a compressed value of * length `bitLength`. The compressed value is in the range [0, 2^(bitLength) - 1], and we are mapping * it back onto the uncompressed range [0, maxUncompressedValue]. * * It is very important that the bitLength and maxUncompressedValue arguments are the * same for compress and decompress, or the results will be meaningless. This must be validated * externally. */ function decompress( uint256 value, uint256 bitLength, uint256 maxUncompressedValue ) internal pure returns (uint256) { // It's not meaningful to compress 1-bit values (2 bits is also a bit silly, but theoretically possible). // 255 would likewise not be very helpful, but is technically valid. _require(bitLength >= 2 && bitLength <= 255, Errors.OUT_OF_BOUNDS); uint256 maxCompressedValue = (1 << bitLength) - 1; // The value must not exceed the maximum compressed value (2**(bitLength) - 1), or it will exceed the max // uncompressed value. _require(value <= maxCompressedValue, Errors.OUT_OF_BOUNDS); return Math.divDown(Math.mul(value, maxUncompressedValue), maxCompressedValue); } // Special case overloads /** * @dev It is very common for the maximum value to be one: Weighted Pool weights, for example. * Overload for this common case, passing FixedPoint.ONE to the general `compress` function. */ function compress(uint256 value, uint256 bitLength) internal pure returns (uint256) { return compress(value, bitLength, FixedPoint.ONE); } /** * @dev It is very common for the maximum value to be one: Weighted Pool weights, for example. * Overload for this common case, passing FixedPoint.ONE to the general `decompress` function. */ function decompress(uint256 value, uint256 bitLength) internal pure returns (uint256) { return decompress(value, bitLength, FixedPoint.ONE); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @title Circuit Breaker Library * @notice Library for logic and functions related to circuit breakers. */ library CircuitBreakerLib { using FixedPoint for uint256; /** * @notice Single-sided check for whether a lower or upper circuit breaker would trip in the given pool state. * @dev Compute the current BPT price from the input parameters, and compare it to the given bound to determine * whether the given post-operation pool state is within the circuit breaker bounds. * @param virtualSupply - the post-operation totalSupply (including protocol fees, etc.) * @param weight - the normalized weight of the token we are checking. * @param balance - the post-operation token balance (including swap fees, etc.). It must be an 18-decimal * floating point number, adjusted by the scaling factor of the token. * @param boundBptPrice - the BPT price at the limit (lower or upper) of the allowed trading range. * @param isLowerBound - true if the boundBptPrice represents the lower bound. * @return - boolean flag for whether the breaker has been tripped. */ function hasCircuitBreakerTripped( uint256 virtualSupply, uint256 weight, uint256 balance, uint256 boundBptPrice, bool isLowerBound ) internal pure returns (bool) { // A bound price of 0 means that no breaker is set. if (boundBptPrice == 0) { return false; } // Round down for lower bound checks, up for upper bound checks uint256 currentBptPrice = Math.div(Math.mul(virtualSupply, weight), balance, !isLowerBound); return isLowerBound ? currentBptPrice < boundBptPrice : currentBptPrice > boundBptPrice; } /** * @notice Convert a bound to a BPT price ratio * @param bound - The bound percentage. * @param weight - The current normalized token weight. * @param isLowerBound - A flag indicating whether this is for a lower bound. */ function calcAdjustedBound( uint256 bound, uint256 weight, bool isLowerBound ) external pure returns (uint256 boundRatio) { // To be conservative and protect LPs, round up for the lower bound, and down for the upper bound. boundRatio = (isLowerBound ? FixedPoint.powUp : FixedPoint.powDown)(bound, weight.complement()); } /** * @notice Convert a BPT price ratio to a BPT price bound * @param boundRatio - The cached bound ratio * @param bptPrice - The BPT price stored at the time the breaker was set. * @param isLowerBound - A flag indicating whether this is for a lower bound. */ function calcBptPriceBoundary( uint256 boundRatio, uint256 bptPrice, bool isLowerBound ) internal pure returns (uint256 boundBptPrice) { // To be conservative and protect LPs, round up for the lower bound, and down for the upper bound. boundBptPrice = (isLowerBound ? FixedPoint.mulUp : FixedPoint.mulDown)(bptPrice, boundRatio); } } /** * @title Circuit Breaker Storage Library * @notice Library for storing and manipulating state related to circuit breakers. * @dev The intent of circuit breakers is to halt trading of a given token if its value changes drastically - * in either direction - with respect to other tokens in the pool. For instance, a stablecoin might de-peg * and go to zero. With no safeguards, arbitrageurs could drain the pool by selling large amounts of the * token to the pool at inflated internal prices. * * The circuit breaker mechanism establishes a "safe trading range" for each token, expressed in terms of * the BPT price. Both lower and upper bounds can be set, and if a trade would result in moving the BPT price * of any token involved in the operation outside that range, the breaker is "tripped", and the operation * should revert. Each token is independent, since some might have very "tight" valid trading ranges, such as * stablecoins, and others are more volatile. * * The BPT price of a token is defined as the amount of BPT that could be redeemed for a single token. * For instance, in an 80/20 pool with a total supply of 1000, the 80% token accounts for 800 BPT. So each * token would be worth 800 / token balance. The formula is then: total supply * token weight / token balance. * (Note that this only applies *if* the pool is balanced (a condition that cannot be checked by the pool without * accessing price oracles.) * * We need to use the BPT price as the measure to ensure we account for the change relative to the rest of * the pool, which could have many other tokens. The drop detected by circuit breakers is analogous to * impermanent loss: it is relative to the performance of the other tokens. If the entire market tanks and * all token balances go down together, the *relative* change would be zero, and the breaker would not be * triggered: even though the external price might have dropped 50 or 70%. It is only the *relative* movement * compared to the rest of the pool that matters. * * If we have tokens A, B, and C, If A drops 20% and B and C are unchanged, that's a simple 20% drop for A. * However, if A is unchanged and C increases 25%, that would also be a 20% "drop" for A 1 / 1.25 = 0.8. * The breaker might register a 20% drop even if both go up - if our target token lags the market. For * instance, if A goes up 60% and B and C double, 1.6 / 2 = 0.8. * * Since BPT prices are not intuitive - and there is a very non-linear relationship between "spot" prices and * BPT prices - circuit breakers are set using simple percentages. Intuitively, a lower bound of 0.8 means the * token can lose 20% of its value before triggering the circuit breaker, and an upper bound of 3.0 means it * can triple before being halted. These percentages are then transformed into BPT prices for comparison to the * "reference" state of the pool when the circuit breaker was set. * * Prices can change in two ways: arbitrage traders responding to external price movement can change the balances, * or an ongoing gradual weight update (or change in pool composition) can change the weights. In order to isolate * the balance changes due to price movement, the bounds are dynamic, adjusted for the current weight. */ library CircuitBreakerStorageLib { using ValueCompression for uint256; using FixedPoint for uint256; using WordCodec for bytes32; // Store circuit breaker information per token // When the circuit breaker is set, the caller passes in the lower and upper bounds (expressed as percentages), // the current BPT price, and the normalized weight. The weight is bound by 1e18, and fits in ~60 bits, so there // is no need for compression. We store the weight in 64 bits, just to use round numbers for all the bit lengths. // // We then store the current BPT price, and compute and cache the adjusted lower and upper bounds at the current // weight. When multiplied by the stored BPT price, the adjusted bounds define the BPT price trading range: the // "runtime" BPT prices can be directly compared to these BPT price bounds. // // Since the price bounds need to be adjusted for the token weight, in general these adjusted bounds would be // computed every time. However, if the weight of the token has not changed since the circuit breaker was set, // the adjusted bounds cache can still be used, avoiding a heavy computation. // // [ 32 bits | 32 bits | 96 bits | 64 bits | 16 bits | 16 bits | // [ adjusted upper bound | adjusted lower bound | BPT price | reference weight | upper bound | lower bound | // |MSB LSB| uint256 private constant _LOWER_BOUND_OFFSET = 0; uint256 private constant _UPPER_BOUND_OFFSET = _LOWER_BOUND_OFFSET + _BOUND_WIDTH; uint256 private constant _REFERENCE_WEIGHT_OFFSET = _UPPER_BOUND_OFFSET + _BOUND_WIDTH; uint256 private constant _BPT_PRICE_OFFSET = _REFERENCE_WEIGHT_OFFSET + _REFERENCE_WEIGHT_WIDTH; uint256 private constant _ADJUSTED_LOWER_BOUND_OFFSET = _BPT_PRICE_OFFSET + _BPT_PRICE_WIDTH; uint256 private constant _ADJUSTED_UPPER_BOUND_OFFSET = _ADJUSTED_LOWER_BOUND_OFFSET + _ADJUSTED_BOUND_WIDTH; uint256 private constant _REFERENCE_WEIGHT_WIDTH = 64; uint256 private constant _BPT_PRICE_WIDTH = 96; uint256 private constant _BOUND_WIDTH = 16; uint256 private constant _ADJUSTED_BOUND_WIDTH = 32; // We allow the bounds to range over two orders of magnitude: 0.1 - 10. The maximum upper bound is set to 10.0 // in 18-decimal floating point, since this fits in 64 bits, and can be shifted down to 16 bit precision without // much loss. Since compression would lose a lot of precision for values close to 0, we also constrain the lower // bound to a minimum value >> 0. // // Since the adjusted bounds are (bound percentage)**(1 - weight), and weights are stored normalized, the // maximum normalized weight is 1 - minimumWeight, which is 0.99 ~ 1. Therefore the adjusted bounds are likewise // constrained to 10**1 ~ 10. So we can use this as the maximum value of both the raw percentage and // weight-adjusted percentage bounds. uint256 private constant _MIN_BOUND_PERCENTAGE = 1e17; // 0.1 in 18-decimal fixed point uint256 private constant _MAX_BOUND_PERCENTAGE = 10e18; // 10.0 in 18-decimal fixed point // Since we know the bounds fit into 64 bits, simply shifting them down to fit in 16 bits is not only faster than // the compression and decompression operations, but generally less lossy. uint256 private constant _BOUND_SHIFT_BITS = 64 - _BOUND_WIDTH; /** * @notice Returns the BPT price, reference weight, and the lower and upper percentage bounds for a given token. * @dev If an upper or lower bound value is zero, it means there is no circuit breaker in that direction for the * given token. * @param circuitBreakerState - The bytes32 state of the token of interest. */ function getCircuitBreakerFields(bytes32 circuitBreakerState) internal pure returns ( uint256 bptPrice, uint256 referenceWeight, uint256 lowerBound, uint256 upperBound ) { bptPrice = circuitBreakerState.decodeUint(_BPT_PRICE_OFFSET, _BPT_PRICE_WIDTH); referenceWeight = circuitBreakerState.decodeUint(_REFERENCE_WEIGHT_OFFSET, _REFERENCE_WEIGHT_WIDTH); // Decompress the bounds by shifting left. lowerBound = circuitBreakerState.decodeUint(_LOWER_BOUND_OFFSET, _BOUND_WIDTH) << _BOUND_SHIFT_BITS; upperBound = circuitBreakerState.decodeUint(_UPPER_BOUND_OFFSET, _BOUND_WIDTH) << _BOUND_SHIFT_BITS; } /** * @notice Returns a dynamic lower or upper BPT price bound for a given token, at the current weight. * @dev The current BPT price of the token can be directly compared to this value, to determine whether * the breaker should be tripped. If a bound is 0, it means there is no circuit breaker in that direction * for this token: there might be a lower bound, but no upper bound. If the current BPT price is less than * the lower bound, or greater than the non-zero upper bound, the transaction should revert. * * These BPT price bounds are dynamically adjusted by a non-linear factor dependent on the weight. * In general: lower/upper BPT price bound = bptPrice * "weight adjustment". The weight adjustment is * given as: (boundaryPercentage)**(1 - weight). * * For instance, given the 80/20 BAL/WETH pool with a 90% lower bound, the weight complement would be * (1 - 0.8) = 0.2, so the lower adjusted bound would be (0.9 ** 0.2) ~ 0.9791. For the WETH token at 20%, * the bound would be (0.9 ** 0.8) ~ 0.9192. * * With unequal weights (assuming a balanced pool), the balance of a higher-weight token will respond less * to a proportional change in spot price than a lower weight token, which we might call "balance inertia". * * If the external price drops, all else being equal, the pool would be arbed until the percent drop in spot * price equaled the external price drop. Since during this process the *internal* pool price would be * above market, the arbers would sell cheap tokens to our poor unwitting pool at inflated prices, raising * the balance of the depreciating token, and lowering the balance of another token (WETH in this example). * * Using weighted math, and assuming for simplicity that the sum of all weights is 1, you can compute the * amountIn ratio for the arb trade as: (1/priceRatio) ** (1 - weight). For our 0.9 ratio and a weight of * 0.8, this is ~ 1.0213. So if you had 8000 tokens before, the ending balance would be 8000*1.0213 ~ 8170. * Note that the higher the weight, the lower this ratio is. That means the counterparty token is going * out proportionally faster than the arb token is coming in: hence the non-linear relationship between * spot price and BPT price. * * If we call the initial balance B0, and set k = (1/priceRatio) ** (1 - weight), the post-arb balance is * given by: B1 = k * B0. Since the BPTPrice0 = totalSupply*weight/B0, and BPTPrice1 = totalSupply*weight/B1, * we can combine these equations to compute the BPT price ratio BPTPrice1/BPTPrice0 = 1/k; BPT1 = BPT0/k. * So we see that the "conversion factor" between the spot price ratio and BPT Price ratio can be written * as above BPT1 = BPT0 * (1/k), or more simply: (BPT price) * (priceRatio)**(1 - weight). * * Another way to think of it is in terms of "BPT Value". Assuming a balanced pool, a token with a weight * of 80% represents 80% of the value of the BPT. An uncorrelated drop in that token's value would drop * the value of LP shares much faster than a similar drop in the value of a 20% token. Whatever the value * of the bound percentage, as the adjustment factor - B ** (1 - weight) - approaches 1, less adjustment * is necessary: it tracks the relative price movement more closely. Intuitively, this is wny we use the * complement of the weight. Higher weight = lower exponent = adjustment factor closer to 1.0 = "faster" * tracking of value changes. * * If the value of the weight has not changed, we can use the cached adjusted bounds stored when the breaker * was set. Otherwise, we need to calculate them. * * As described in the general comments above, the weight adjustment calculation attempts to isolate changes * in the balance due to arbitrageurs responding to external prices, from internal price changes caused by * weight changes. There is a non-linear relationship between "spot" price changes and BPT price changes. * This calculation transforms one into the other. * @param circuitBreakerState - The bytes32 state of the token of interest. * @param currentWeight - The token's current normalized weight. * @param isLowerBound - Flag indicating whether this is the lower bound. * @return - lower or upper bound BPT price, which can be directly compared against the current BPT price. */ function getBptPriceBound( bytes32 circuitBreakerState, uint256 currentWeight, bool isLowerBound ) internal pure returns (uint256) { uint256 bound = circuitBreakerState.decodeUint( isLowerBound ? _LOWER_BOUND_OFFSET : _UPPER_BOUND_OFFSET, _BOUND_WIDTH ) << _BOUND_SHIFT_BITS; if (bound == 0) { return 0; } // Retrieve the BPT price and reference weight passed in when the circuit breaker was set. uint256 bptPrice = circuitBreakerState.decodeUint(_BPT_PRICE_OFFSET, _BPT_PRICE_WIDTH); uint256 referenceWeight = circuitBreakerState.decodeUint(_REFERENCE_WEIGHT_OFFSET, _REFERENCE_WEIGHT_WIDTH); uint256 boundRatio; if (currentWeight == referenceWeight) { // If the weight hasn't changed since the circuit breaker was set, we can use the precomputed // adjusted bounds. boundRatio = circuitBreakerState .decodeUint( isLowerBound ? _ADJUSTED_LOWER_BOUND_OFFSET : _ADJUSTED_UPPER_BOUND_OFFSET, _ADJUSTED_BOUND_WIDTH ) .decompress(_ADJUSTED_BOUND_WIDTH, _MAX_BOUND_PERCENTAGE); } else { // The weight has changed, so we retrieve the raw percentage bounds and do the full calculation. // Decompress the bounds by shifting left. boundRatio = CircuitBreakerLib.calcAdjustedBound(bound, currentWeight, isLowerBound); } // Use the adjusted bounds (either cached or computed) to calculate the BPT price bounds. return CircuitBreakerLib.calcBptPriceBoundary(boundRatio, bptPrice, isLowerBound); } /** * @notice Sets the reference BPT price, normalized weight, and upper and lower bounds for a token. * @dev If a bound is zero, it means there is no circuit breaker in that direction for the given token. * @param bptPrice: The BPT price of the token at the time the circuit breaker is set. The BPT Price * of a token is generally given by: supply * weight / balance. * @param referenceWeight: This is the current normalized weight of the token. * @param lowerBound: The value of the lower bound, expressed as a percentage. * @param upperBound: The value of the upper bound, expressed as a percentage. */ function setCircuitBreaker( uint256 bptPrice, uint256 referenceWeight, uint256 lowerBound, uint256 upperBound ) internal pure returns (bytes32) { // It's theoretically not required for the lower bound to be < 1, but it wouldn't make much sense otherwise: // the circuit breaker would immediately trip. Note that this explicitly allows setting either to 0, disabling // the circuit breaker for the token in that direction. _require( lowerBound == 0 || (lowerBound >= _MIN_BOUND_PERCENTAGE && lowerBound <= FixedPoint.ONE), Errors.INVALID_CIRCUIT_BREAKER_BOUNDS ); _require(upperBound <= _MAX_BOUND_PERCENTAGE, Errors.INVALID_CIRCUIT_BREAKER_BOUNDS); _require(upperBound == 0 || upperBound >= lowerBound, Errors.INVALID_CIRCUIT_BREAKER_BOUNDS); // Set the reference parameters: BPT price of the token, and the reference weight. bytes32 circuitBreakerState = bytes32(0).insertUint(bptPrice, _BPT_PRICE_OFFSET, _BPT_PRICE_WIDTH).insertUint( referenceWeight, _REFERENCE_WEIGHT_OFFSET, _REFERENCE_WEIGHT_WIDTH ); // Add the lower and upper percentage bounds. Compress by shifting right. circuitBreakerState = circuitBreakerState .insertUint(lowerBound >> _BOUND_SHIFT_BITS, _LOWER_BOUND_OFFSET, _BOUND_WIDTH) .insertUint(upperBound >> _BOUND_SHIFT_BITS, _UPPER_BOUND_OFFSET, _BOUND_WIDTH); // Precompute and store the adjusted bounds, used to convert percentage bounds to BPT price bounds. // If the weight has not changed since the breaker was set, we can use the precomputed values directly, // and avoid a heavy computation. uint256 adjustedLowerBound = CircuitBreakerLib.calcAdjustedBound(lowerBound, referenceWeight, true); uint256 adjustedUpperBound = CircuitBreakerLib.calcAdjustedBound(upperBound, referenceWeight, false); // Finally, insert these computed adjusted bounds, and return the complete set of fields. return circuitBreakerState .insertUint( adjustedLowerBound.compress(_ADJUSTED_BOUND_WIDTH, _MAX_BOUND_PERCENTAGE), _ADJUSTED_LOWER_BOUND_OFFSET, _ADJUSTED_BOUND_WIDTH ) .insertUint( adjustedUpperBound.compress(_ADJUSTED_BOUND_WIDTH, _MAX_BOUND_PERCENTAGE), _ADJUSTED_UPPER_BOUND_OFFSET, _ADJUSTED_BOUND_WIDTH ); } /** * @notice Update the cached adjusted bounds, given a new weight. * @dev This might be used when weights are adjusted, pre-emptively updating the cache to improve performance * of operations after the weight change completes. Note that this does not update the BPT price: this is still * relative to the last call to `setCircuitBreaker`. The intent is only to optimize the automatic bounds * adjustments due to changing weights. */ function updateAdjustedBounds(bytes32 circuitBreakerState, uint256 newReferenceWeight) internal pure returns (bytes32) { uint256 adjustedLowerBound = CircuitBreakerLib.calcAdjustedBound( circuitBreakerState.decodeUint(_LOWER_BOUND_OFFSET, _BOUND_WIDTH) << _BOUND_SHIFT_BITS, newReferenceWeight, true ); uint256 adjustedUpperBound = CircuitBreakerLib.calcAdjustedBound( circuitBreakerState.decodeUint(_UPPER_BOUND_OFFSET, _BOUND_WIDTH) << _BOUND_SHIFT_BITS, newReferenceWeight, false ); // Replace the reference weight. bytes32 result = circuitBreakerState.insertUint( newReferenceWeight, _REFERENCE_WEIGHT_OFFSET, _REFERENCE_WEIGHT_WIDTH ); // Update the cached adjusted bounds. return result .insertUint( adjustedLowerBound.compress(_ADJUSTED_BOUND_WIDTH, _MAX_BOUND_PERCENTAGE), _ADJUSTED_LOWER_BOUND_OFFSET, _ADJUSTED_BOUND_WIDTH ) .insertUint( adjustedUpperBound.compress(_ADJUSTED_BOUND_WIDTH, _MAX_BOUND_PERCENTAGE), _ADJUSTED_UPPER_BOUND_OFFSET, _ADJUSTED_BOUND_WIDTH ); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // These functions start with an underscore, as if they were part of a contract and not a library. At some point this // should be fixed. // solhint-disable private-vars-leading-underscore library WeightedMath { using FixedPoint for uint256; // A minimum normalized weight imposes a maximum weight ratio. We need this due to limitations in the // implementation of the power function, as these ratios are often exponents. uint256 internal constant _MIN_WEIGHT = 0.01e18; // Having a minimum normalized weight imposes a limit on the maximum number of tokens; // i.e., the largest possible pool is one where all tokens have exactly the minimum weight. uint256 internal constant _MAX_WEIGHTED_TOKENS = 100; // Pool limits that arise from limitations in the fixed point power function (and the imposed 1:100 maximum weight // ratio). // Swap limits: amounts swapped may not be larger than this percentage of total balance. uint256 internal constant _MAX_IN_RATIO = 0.3e18; uint256 internal constant _MAX_OUT_RATIO = 0.3e18; // Invariant growth limit: non-proportional joins cannot cause the invariant to increase by more than this ratio. uint256 internal constant _MAX_INVARIANT_RATIO = 3e18; // Invariant shrink limit: non-proportional exits cannot cause the invariant to decrease by less than this ratio. uint256 internal constant _MIN_INVARIANT_RATIO = 0.7e18; // About swap fees on joins and exits: // Any join or exit that is not perfectly balanced (e.g. all single token joins or exits) is mathematically // equivalent to a perfectly balanced join or exit followed by a series of swaps. Since these swaps would charge // swap fees, it follows that (some) joins and exits should as well. // On these operations, we split the token amounts in 'taxable' and 'non-taxable' portions, where the 'taxable' part // is the one to which swap fees are applied. // Invariant is used to collect protocol swap fees by comparing its value between two times. // So we can round always to the same direction. It is also used to initiate the BPT amount // and, because there is a minimum BPT, we round down the invariant. function _calculateInvariant(uint256[] memory normalizedWeights, uint256[] memory balances) internal pure returns (uint256 invariant) { /********************************************************************************************** // invariant _____ // // wi = weight index i | | wi // // bi = balance index i | | bi ^ = i // // i = invariant // **********************************************************************************************/ invariant = FixedPoint.ONE; for (uint256 i = 0; i < normalizedWeights.length; i++) { invariant = invariant.mulDown(balances[i].powDown(normalizedWeights[i])); } _require(invariant > 0, Errors.ZERO_INVARIANT); } // Computes how many tokens can be taken out of a pool if `amountIn` are sent, given the // current balances and weights. function _calcOutGivenIn( uint256 balanceIn, uint256 weightIn, uint256 balanceOut, uint256 weightOut, uint256 amountIn ) internal pure returns (uint256) { /********************************************************************************************** // outGivenIn // // aO = amountOut // // bO = balanceOut // // bI = balanceIn / / bI \ (wI / wO) \ // // aI = amountIn aO = bO * | 1 - | -------------------------- | ^ | // // wI = weightIn \ \ ( bI + aI ) / / // // wO = weightOut // **********************************************************************************************/ // Amount out, so we round down overall. // The multiplication rounds down, and the subtrahend (power) rounds up (so the base rounds up too). // Because bI / (bI + aI) <= 1, the exponent rounds down. // Cannot exceed maximum in ratio _require(amountIn <= balanceIn.mulDown(_MAX_IN_RATIO), Errors.MAX_IN_RATIO); uint256 denominator = balanceIn.add(amountIn); uint256 base = balanceIn.divUp(denominator); uint256 exponent = weightIn.divDown(weightOut); uint256 power = base.powUp(exponent); return balanceOut.mulDown(power.complement()); } // Computes how many tokens must be sent to a pool in order to take `amountOut`, given the // current balances and weights. function _calcInGivenOut( uint256 balanceIn, uint256 weightIn, uint256 balanceOut, uint256 weightOut, uint256 amountOut ) internal pure returns (uint256) { /********************************************************************************************** // inGivenOut // // aO = amountOut // // bO = balanceOut // // bI = balanceIn / / bO \ (wO / wI) \ // // aI = amountIn aI = bI * | | -------------------------- | ^ - 1 | // // wI = weightIn \ \ ( bO - aO ) / / // // wO = weightOut // **********************************************************************************************/ // Amount in, so we round up overall. // The multiplication rounds up, and the power rounds up (so the base rounds up too). // Because b0 / (b0 - a0) >= 1, the exponent rounds up. // Cannot exceed maximum out ratio _require(amountOut <= balanceOut.mulDown(_MAX_OUT_RATIO), Errors.MAX_OUT_RATIO); uint256 base = balanceOut.divUp(balanceOut.sub(amountOut)); uint256 exponent = weightOut.divUp(weightIn); uint256 power = base.powUp(exponent); // Because the base is larger than one (and the power rounds up), the power should always be larger than one, so // the following subtraction should never revert. uint256 ratio = power.sub(FixedPoint.ONE); return balanceIn.mulUp(ratio); } function _calcBptOutGivenExactTokensIn( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) internal pure returns (uint256) { // BPT out, so we round down overall. uint256[] memory balanceRatiosWithFee = new uint256[](amountsIn.length); uint256 invariantRatioWithFees = 0; for (uint256 i = 0; i < balances.length; i++) { balanceRatiosWithFee[i] = balances[i].add(amountsIn[i]).divDown(balances[i]); invariantRatioWithFees = invariantRatioWithFees.add(balanceRatiosWithFee[i].mulDown(normalizedWeights[i])); } uint256 invariantRatio = _computeJoinExactTokensInInvariantRatio( balances, normalizedWeights, amountsIn, balanceRatiosWithFee, invariantRatioWithFees, swapFeePercentage ); uint256 bptOut = (invariantRatio > FixedPoint.ONE) ? bptTotalSupply.mulDown(invariantRatio - FixedPoint.ONE) : 0; return bptOut; } function _calcBptOutGivenExactTokenIn( uint256 balance, uint256 normalizedWeight, uint256 amountIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) internal pure returns (uint256) { // BPT out, so we round down overall. uint256 amountInWithoutFee; { uint256 balanceRatioWithFee = balance.add(amountIn).divDown(balance); // The use of `normalizedWeight.complement()` assumes that the sum of all weights equals FixedPoint.ONE. // This may not be the case when weights are stored in a denormalized format or during a gradual weight // change due rounding errors during normalization or interpolation. This will result in a small difference // between the output of this function and the equivalent `_calcBptOutGivenExactTokensIn` call. uint256 invariantRatioWithFees = balanceRatioWithFee.mulDown(normalizedWeight).add( normalizedWeight.complement() ); if (balanceRatioWithFee > invariantRatioWithFees) { uint256 nonTaxableAmount = invariantRatioWithFees > FixedPoint.ONE ? balance.mulDown(invariantRatioWithFees - FixedPoint.ONE) : 0; uint256 taxableAmount = amountIn.sub(nonTaxableAmount); uint256 swapFee = taxableAmount.mulUp(swapFeePercentage); amountInWithoutFee = nonTaxableAmount.add(taxableAmount.sub(swapFee)); } else { amountInWithoutFee = amountIn; // If a token's amount in is not being charged a swap fee then it might be zero. // In this case, it's clear that the sender should receive no BPT. if (amountInWithoutFee == 0) { return 0; } } } uint256 balanceRatio = balance.add(amountInWithoutFee).divDown(balance); uint256 invariantRatio = balanceRatio.powDown(normalizedWeight); uint256 bptOut = (invariantRatio > FixedPoint.ONE) ? bptTotalSupply.mulDown(invariantRatio - FixedPoint.ONE) : 0; return bptOut; } /** * @dev Intermediate function to avoid stack-too-deep errors. */ function _computeJoinExactTokensInInvariantRatio( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsIn, uint256[] memory balanceRatiosWithFee, uint256 invariantRatioWithFees, uint256 swapFeePercentage ) private pure returns (uint256 invariantRatio) { // Swap fees are charged on all tokens that are being added in a larger proportion than the overall invariant // increase. invariantRatio = FixedPoint.ONE; for (uint256 i = 0; i < balances.length; i++) { uint256 amountInWithoutFee; if (balanceRatiosWithFee[i] > invariantRatioWithFees) { // invariantRatioWithFees might be less than FixedPoint.ONE in edge scenarios due to rounding error, // particularly if the weights don't exactly add up to 100%. uint256 nonTaxableAmount = invariantRatioWithFees > FixedPoint.ONE ? balances[i].mulDown(invariantRatioWithFees - FixedPoint.ONE) : 0; uint256 swapFee = amountsIn[i].sub(nonTaxableAmount).mulUp(swapFeePercentage); amountInWithoutFee = amountsIn[i].sub(swapFee); } else { amountInWithoutFee = amountsIn[i]; // If a token's amount in is not being charged a swap fee then it might be zero (e.g. when joining a // Pool with only a subset of tokens). In this case, `balanceRatio` will equal `FixedPoint.ONE`, and // the `invariantRatio` will not change at all. We therefore skip to the next iteration, avoiding // the costly `powDown` call. if (amountInWithoutFee == 0) { continue; } } uint256 balanceRatio = balances[i].add(amountInWithoutFee).divDown(balances[i]); invariantRatio = invariantRatio.mulDown(balanceRatio.powDown(normalizedWeights[i])); } } function _calcTokenInGivenExactBptOut( uint256 balance, uint256 normalizedWeight, uint256 bptAmountOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) internal pure returns (uint256) { /****************************************************************************************** // tokenInForExactBPTOut // // a = amountIn // // b = balance / / totalBPT + bptOut \ (1 / w) \ // // bptOut = bptAmountOut a = b * | | -------------------------- | ^ - 1 | // // bpt = totalBPT \ \ totalBPT / / // // w = weight // ******************************************************************************************/ // Token in, so we round up overall. // Calculate the factor by which the invariant will increase after minting BPTAmountOut uint256 invariantRatio = bptTotalSupply.add(bptAmountOut).divUp(bptTotalSupply); _require(invariantRatio <= _MAX_INVARIANT_RATIO, Errors.MAX_OUT_BPT_FOR_TOKEN_IN); // Calculate by how much the token balance has to increase to match the invariantRatio uint256 balanceRatio = invariantRatio.powUp(FixedPoint.ONE.divUp(normalizedWeight)); uint256 amountInWithoutFee = balance.mulUp(balanceRatio.sub(FixedPoint.ONE)); // We can now compute how much extra balance is being deposited and used in virtual swaps, and charge swap fees // accordingly. uint256 taxableAmount = amountInWithoutFee.mulUp(normalizedWeight.complement()); uint256 nonTaxableAmount = amountInWithoutFee.sub(taxableAmount); uint256 taxableAmountPlusFees = taxableAmount.divUp(swapFeePercentage.complement()); return nonTaxableAmount.add(taxableAmountPlusFees); } function _calcBptInGivenExactTokensOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) internal pure returns (uint256) { // BPT in, so we round up overall. uint256[] memory balanceRatiosWithoutFee = new uint256[](amountsOut.length); uint256 invariantRatioWithoutFees = 0; for (uint256 i = 0; i < balances.length; i++) { balanceRatiosWithoutFee[i] = balances[i].sub(amountsOut[i]).divUp(balances[i]); invariantRatioWithoutFees = invariantRatioWithoutFees.add( balanceRatiosWithoutFee[i].mulUp(normalizedWeights[i]) ); } uint256 invariantRatio = _computeExitExactTokensOutInvariantRatio( balances, normalizedWeights, amountsOut, balanceRatiosWithoutFee, invariantRatioWithoutFees, swapFeePercentage ); return bptTotalSupply.mulUp(invariantRatio.complement()); } function _calcBptInGivenExactTokenOut( uint256 balance, uint256 normalizedWeight, uint256 amountOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) internal pure returns (uint256) { // BPT in, so we round up overall. uint256 balanceRatioWithoutFee = balance.sub(amountOut).divUp(balance); uint256 invariantRatioWithoutFees = balanceRatioWithoutFee.mulUp(normalizedWeight).add( normalizedWeight.complement() ); uint256 amountOutWithFee; if (invariantRatioWithoutFees > balanceRatioWithoutFee) { // Swap fees are typically charged on 'token in', but there is no 'token in' here, so we apply it to // 'token out'. This results in slightly larger price impact. uint256 nonTaxableAmount = balance.mulDown(invariantRatioWithoutFees.complement()); uint256 taxableAmount = amountOut.sub(nonTaxableAmount); uint256 taxableAmountPlusFees = taxableAmount.divUp(swapFeePercentage.complement()); amountOutWithFee = nonTaxableAmount.add(taxableAmountPlusFees); } else { amountOutWithFee = amountOut; // If a token's amount out is not being charged a swap fee then it might be zero. // In this case, it's clear that the sender should not send any BPT. if (amountOutWithFee == 0) { return 0; } } uint256 balanceRatio = balance.sub(amountOutWithFee).divDown(balance); uint256 invariantRatio = balanceRatio.powDown(normalizedWeight); return bptTotalSupply.mulUp(invariantRatio.complement()); } /** * @dev Intermediate function to avoid stack-too-deep errors. */ function _computeExitExactTokensOutInvariantRatio( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsOut, uint256[] memory balanceRatiosWithoutFee, uint256 invariantRatioWithoutFees, uint256 swapFeePercentage ) private pure returns (uint256 invariantRatio) { invariantRatio = FixedPoint.ONE; for (uint256 i = 0; i < balances.length; i++) { // Swap fees are typically charged on 'token in', but there is no 'token in' here, so we apply it to // 'token out'. This results in slightly larger price impact. uint256 amountOutWithFee; if (invariantRatioWithoutFees > balanceRatiosWithoutFee[i]) { uint256 nonTaxableAmount = balances[i].mulDown(invariantRatioWithoutFees.complement()); uint256 taxableAmount = amountsOut[i].sub(nonTaxableAmount); uint256 taxableAmountPlusFees = taxableAmount.divUp(swapFeePercentage.complement()); amountOutWithFee = nonTaxableAmount.add(taxableAmountPlusFees); } else { amountOutWithFee = amountsOut[i]; // If a token's amount out is not being charged a swap fee then it might be zero (e.g. when exiting a // Pool with only a subset of tokens). In this case, `balanceRatio` will equal `FixedPoint.ONE`, and // the `invariantRatio` will not change at all. We therefore skip to the next iteration, avoiding // the costly `powDown` call. if (amountOutWithFee == 0) { continue; } } uint256 balanceRatio = balances[i].sub(amountOutWithFee).divDown(balances[i]); invariantRatio = invariantRatio.mulDown(balanceRatio.powDown(normalizedWeights[i])); } } function _calcTokenOutGivenExactBptIn( uint256 balance, uint256 normalizedWeight, uint256 bptAmountIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) internal pure returns (uint256) { /***************************************************************************************** // exactBPTInForTokenOut // // a = amountOut // // b = balance / / totalBPT - bptIn \ (1 / w) \ // // bptIn = bptAmountIn a = b * | 1 - | -------------------------- | ^ | // // bpt = totalBPT \ \ totalBPT / / // // w = weight // *****************************************************************************************/ // Token out, so we round down overall. The multiplication rounds down, but the power rounds up (so the base // rounds up). Because (totalBPT - bptIn) / totalBPT <= 1, the exponent rounds down. // Calculate the factor by which the invariant will decrease after burning BPTAmountIn uint256 invariantRatio = bptTotalSupply.sub(bptAmountIn).divUp(bptTotalSupply); _require(invariantRatio >= _MIN_INVARIANT_RATIO, Errors.MIN_BPT_IN_FOR_TOKEN_OUT); // Calculate by how much the token balance has to decrease to match invariantRatio uint256 balanceRatio = invariantRatio.powUp(FixedPoint.ONE.divDown(normalizedWeight)); // Because of rounding up, balanceRatio can be greater than one. Using complement prevents reverts. uint256 amountOutWithoutFee = balance.mulDown(balanceRatio.complement()); // We can now compute how much excess balance is being withdrawn as a result of the virtual swaps, which result // in swap fees. // Swap fees are typically charged on 'token in', but there is no 'token in' here, so we apply it // to 'token out'. This results in slightly larger price impact. Fees are rounded up. uint256 taxableAmount = amountOutWithoutFee.mulUp(normalizedWeight.complement()); uint256 nonTaxableAmount = amountOutWithoutFee.sub(taxableAmount); uint256 taxableAmountMinusFees = taxableAmount.mulUp(swapFeePercentage.complement()); return nonTaxableAmount.add(taxableAmountMinusFees); } /** * @dev Calculate the amount of BPT which should be minted when adding a new token to the Pool. * * Note that normalizedWeight is set that it corresponds to the desired weight of this token *after* adding it. * i.e. For a two token 50:50 pool which we want to turn into a 33:33:33 pool, we use a normalized weight of 33% * @param totalSupply - the total supply of the Pool's BPT. * @param normalizedWeight - the normalized weight of the token to be added (normalized relative to final weights) */ function _calcBptOutAddToken(uint256 totalSupply, uint256 normalizedWeight) internal pure returns (uint256) { // The amount of BPT which is equivalent to the token being added may be calculated by the growth in the // sum of the token weights, i.e. if we add a token which will make up 50% of the pool then we should receive // 50% of the new supply of BPT. // // The growth in the total weight of the pool can be easily calculated by: // // weightSumRatio = totalWeight / (totalWeight - newTokenWeight) // // As we're working with normalized weights `totalWeight` is equal to 1. uint256 weightSumRatio = FixedPoint.ONE.divDown(FixedPoint.ONE.sub(normalizedWeight)); // The amount of BPT to mint is then simply: // // toMint = totalSupply * (weightSumRatio - 1) return totalSupply.mulDown(weightSumRatio.sub(FixedPoint.ONE)); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @title Managed Pool Storage Library * @notice Library for manipulating a bitmap used for commonly used Pool state in ManagedPool. */ library ManagedPoolStorageLib { using WordCodec for bytes32; /* solhint-disable max-line-length */ // Store non-token-based values: // Start/end timestamps for gradual weight and swap fee updates // Start/end values of the swap fee // Flags for the LP allowlist, enabling/disabling trading, enabling/disabling joins and exits, and recovery mode // // [ 1 bit | 1 bit | 1 bit | 1 bit | 62 bits | 62 bits | 32 bits | 32 bits | 32 bits | 32 bits ] // [ join-exit flag | recovery | LP flag | swap flag | end swap fee | start swap fee | end fee time | start fee time | end wgt | start wgt ] // |MSB LSB| /* solhint-enable max-line-length */ uint256 private constant _WEIGHT_START_TIME_OFFSET = 0; uint256 private constant _WEIGHT_END_TIME_OFFSET = _WEIGHT_START_TIME_OFFSET + _TIMESTAMP_WIDTH; uint256 private constant _SWAP_FEE_START_TIME_OFFSET = _WEIGHT_END_TIME_OFFSET + _TIMESTAMP_WIDTH; uint256 private constant _SWAP_FEE_END_TIME_OFFSET = _SWAP_FEE_START_TIME_OFFSET + _TIMESTAMP_WIDTH; uint256 private constant _SWAP_FEE_START_PCT_OFFSET = _SWAP_FEE_END_TIME_OFFSET + _TIMESTAMP_WIDTH; uint256 private constant _SWAP_FEE_END_PCT_OFFSET = _SWAP_FEE_START_PCT_OFFSET + _SWAP_FEE_PCT_WIDTH; uint256 private constant _SWAP_ENABLED_OFFSET = _SWAP_FEE_END_PCT_OFFSET + _SWAP_FEE_PCT_WIDTH; uint256 private constant _MUST_ALLOWLIST_LPS_OFFSET = _SWAP_ENABLED_OFFSET + 1; uint256 private constant _RECOVERY_MODE_OFFSET = _MUST_ALLOWLIST_LPS_OFFSET + 1; uint256 private constant _JOIN_EXIT_ENABLED_OFFSET = _RECOVERY_MODE_OFFSET + 1; uint256 private constant _TIMESTAMP_WIDTH = 32; // 2**60 ~= 1.1e18 so this is sufficient to store the full range of potential swap fees. uint256 private constant _SWAP_FEE_PCT_WIDTH = 62; // Getters /** * @notice Returns whether the Pool allows regular joins and exits (recovery exits not included). * @param poolState - The byte32 state of the Pool. */ function getJoinExitEnabled(bytes32 poolState) internal pure returns (bool) { return poolState.decodeBool(_JOIN_EXIT_ENABLED_OFFSET); } /** * @notice Returns whether the Pool is currently in Recovery Mode. * @param poolState - The byte32 state of the Pool. */ function getRecoveryModeEnabled(bytes32 poolState) internal pure returns (bool) { return poolState.decodeBool(_RECOVERY_MODE_OFFSET); } /** * @notice Returns whether the Pool currently allows swaps (and by extension, non-proportional joins/exits). * @param poolState - The byte32 state of the Pool. */ function getSwapEnabled(bytes32 poolState) internal pure returns (bool) { return poolState.decodeBool(_SWAP_ENABLED_OFFSET); } /** * @notice Returns whether addresses must be allowlisted to add liquidity to the Pool. * @param poolState - The byte32 state of the Pool. */ function getLPAllowlistEnabled(bytes32 poolState) internal pure returns (bool) { return poolState.decodeBool(_MUST_ALLOWLIST_LPS_OFFSET); } /** * @notice Returns the percentage progress through the current gradual weight change. * @param poolState - The byte32 state of the Pool. * @return pctProgress - A 18 decimal fixed-point value corresponding to how far to interpolate between the start * and end weights. 0 represents the start weight and 1 represents the end weight (with values >1 being clipped). */ function getGradualWeightChangeProgress(bytes32 poolState) internal view returns (uint256) { (uint256 startTime, uint256 endTime) = getWeightChangeFields(poolState); return GradualValueChange.calculateValueChangeProgress(startTime, endTime); } /** * @notice Returns the start and end timestamps of the current gradual weight change. * @param poolState - The byte32 state of the Pool. * @param startTime - The timestamp at which the current gradual weight change started/will start. * @param endTime - The timestamp at which the current gradual weight change finished/will finish. */ function getWeightChangeFields(bytes32 poolState) internal pure returns (uint256 startTime, uint256 endTime) { startTime = poolState.decodeUint(_WEIGHT_START_TIME_OFFSET, _TIMESTAMP_WIDTH); endTime = poolState.decodeUint(_WEIGHT_END_TIME_OFFSET, _TIMESTAMP_WIDTH); } /** * @notice Returns the current value of the swap fee percentage. * @dev Computes the current swap fee percentage, which can change every block if a gradual swap fee * update is in progress. * @param poolState - The byte32 state of the Pool. */ function getSwapFeePercentage(bytes32 poolState) internal view returns (uint256) { ( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) = getSwapFeeFields(poolState); return GradualValueChange.getInterpolatedValue(startSwapFeePercentage, endSwapFeePercentage, startTime, endTime); } /** * @notice Returns the start and end timestamps of the current gradual weight change. * @param poolState - The byte32 state of the Pool. * @return startTime - The timestamp at which the current gradual swap fee change started/will start. * @return endTime - The timestamp at which the current gradual swap fee change finished/will finish. * @return startSwapFeePercentage - The swap fee value at the start of the current gradual swap fee change. * @return endSwapFeePercentage - The swap fee value at the end of the current gradual swap fee change. */ function getSwapFeeFields(bytes32 poolState) internal pure returns ( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) { startTime = poolState.decodeUint(_SWAP_FEE_START_TIME_OFFSET, _TIMESTAMP_WIDTH); endTime = poolState.decodeUint(_SWAP_FEE_END_TIME_OFFSET, _TIMESTAMP_WIDTH); startSwapFeePercentage = poolState.decodeUint(_SWAP_FEE_START_PCT_OFFSET, _SWAP_FEE_PCT_WIDTH); endSwapFeePercentage = poolState.decodeUint(_SWAP_FEE_END_PCT_OFFSET, _SWAP_FEE_PCT_WIDTH); } // Setters /** * @notice Sets the "Joins/Exits enabled" flag to `enabled`. * @param poolState - The byte32 state of the Pool. * @param enabled - A boolean flag for whether Joins and Exits are to be enabled. */ function setJoinExitEnabled(bytes32 poolState, bool enabled) internal pure returns (bytes32) { return poolState.insertBool(enabled, _JOIN_EXIT_ENABLED_OFFSET); } /** * @notice Sets the "Recovery Mode enabled" flag to `enabled`. * @param poolState - The byte32 state of the Pool. * @param enabled - A boolean flag for whether Recovery Mode is to be enabled. */ function setRecoveryModeEnabled(bytes32 poolState, bool enabled) internal pure returns (bytes32) { return poolState.insertBool(enabled, _RECOVERY_MODE_OFFSET); } /** * @notice Sets the "swaps enabled" flag to `enabled`. * @param poolState - The byte32 state of the Pool. * @param enabled - A boolean flag for whether swaps are to be enabled. */ function setSwapEnabled(bytes32 poolState, bool enabled) internal pure returns (bytes32) { return poolState.insertBool(enabled, _SWAP_ENABLED_OFFSET); } /** * @notice Sets the "LP allowlist enabled" flag to `enabled`. * @param poolState - The byte32 state of the Pool. * @param enabled - A boolean flag for whether the LP allowlist is to be enforced. */ function setLPAllowlistEnabled(bytes32 poolState, bool enabled) internal pure returns (bytes32) { return poolState.insertBool(enabled, _MUST_ALLOWLIST_LPS_OFFSET); } /** * @notice Sets the start and end times of a gradual weight change. * @param poolState - The byte32 state of the Pool. * @param startTime - The timestamp at which the gradual weight change is to start. * @param endTime - The timestamp at which the gradual weight change is to finish. */ function setWeightChangeData( bytes32 poolState, uint256 startTime, uint256 endTime ) internal pure returns (bytes32) { poolState = poolState.insertUint(startTime, _WEIGHT_START_TIME_OFFSET, _TIMESTAMP_WIDTH); return poolState.insertUint(endTime, _WEIGHT_END_TIME_OFFSET, _TIMESTAMP_WIDTH); } /** * @notice Sets the start and end times of a gradual swap fee change. * @param poolState - The byte32 state of the Pool. * @param startTime - The timestamp at which the gradual swap fee change is to start. * @param endTime - The timestamp at which the gradual swap fee change is to finish. * @param startSwapFeePercentage - The desired swap fee value at the start of the gradual swap fee change. * @param endSwapFeePercentage - The desired swap fee value at the end of the gradual swap fee change. */ function setSwapFeeData( bytes32 poolState, uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) internal pure returns (bytes32) { poolState = poolState.insertUint(startTime, _SWAP_FEE_START_TIME_OFFSET, _TIMESTAMP_WIDTH); poolState = poolState.insertUint(endTime, _SWAP_FEE_END_TIME_OFFSET, _TIMESTAMP_WIDTH); poolState = poolState.insertUint(startSwapFeePercentage, _SWAP_FEE_START_PCT_OFFSET, _SWAP_FEE_PCT_WIDTH); return poolState.insertUint(endSwapFeePercentage, _SWAP_FEE_END_PCT_OFFSET, _SWAP_FEE_PCT_WIDTH); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @title Managed Pool AUM Storage Library * @notice Library for manipulating a bitmap used for Pool state used for charging AUM fees in ManagedPool. */ library ManagedPoolAumStorageLib { using WordCodec for bytes32; // Store AUM fee values: // Percentage of AUM to be paid as fees yearly. // Timestamp of the most recent collection of AUM fees. // // [ 164 bit | 32 bits | 60 bits ] // [ unused | last collection time | aum fee pct. ] // |MSB LSB| uint256 private constant _AUM_FEE_PERCENTAGE_OFFSET = 0; uint256 private constant _LAST_COLLECTION_TIMESTAMP_OFFSET = _AUM_FEE_PERCENTAGE_OFFSET + _AUM_FEE_PCT_WIDTH; uint256 private constant _TIMESTAMP_WIDTH = 32; // 2**60 ~= 1.1e18 so this is sufficient to store the full range of potential AUM fees. uint256 private constant _AUM_FEE_PCT_WIDTH = 60; // Getters /** * @notice Returns the current AUM fee percentage and the timestamp of the last fee collection. * @param aumState - The byte32 state of the Pool's AUM fees. * @return aumFeePercentage - The percentage of the AUM of the Pool to be charged as fees yearly. * @return lastCollectionTimestamp - The timestamp of the last collection of AUM fees. */ function getAumFeeFields(bytes32 aumState) internal pure returns (uint256 aumFeePercentage, uint256 lastCollectionTimestamp) { aumFeePercentage = aumState.decodeUint(_AUM_FEE_PERCENTAGE_OFFSET, _AUM_FEE_PCT_WIDTH); lastCollectionTimestamp = aumState.decodeUint(_LAST_COLLECTION_TIMESTAMP_OFFSET, _TIMESTAMP_WIDTH); } // Setters /** * @notice Sets the AUM fee percentage describing what fraction of the Pool should be charged as fees yearly. * @param aumState - The byte32 state of the Pool's AUM fees. * @param aumFeePercentage - The new percentage of the AUM of the Pool to be charged as fees yearly. */ function setAumFeePercentage(bytes32 aumState, uint256 aumFeePercentage) internal pure returns (bytes32) { return aumState.insertUint(aumFeePercentage, _AUM_FEE_PERCENTAGE_OFFSET, _AUM_FEE_PCT_WIDTH); } /** * @notice Sets the timestamp of the last collection of AUM fees * @param aumState - The byte32 state of the Pool's AUM fees. * @param timestamp - The timestamp of the last collection of AUM fees. `block.timestamp` should usually be passed. */ function setLastCollectionTimestamp(bytes32 aumState, uint256 timestamp) internal pure returns (bytes32) { return aumState.insertUint(timestamp, _LAST_COLLECTION_TIMESTAMP_OFFSET, _TIMESTAMP_WIDTH); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. /** * @title Managed Pool Token Library * @notice Library for manipulating bitmaps used for storing token-related state in ManagedPool. * @dev * * This library stores all token weights in a normalized format, meaning they add up to 100% (1.0 in 18 decimal fixed * point format). */ library ManagedPoolTokenStorageLib { using WordCodec for bytes32; using FixedPoint for uint256; // Store token-based values: // Each token's scaling factor (encoded as the scaling factor's exponent / token decimals). // Each token's starting and ending normalized weights. // [ 123 bits | 5 bits | 64 bits | 64 bits | // [ unused | decimals | end norm weight | start norm weight | // |MSB LSB| uint256 private constant _START_NORM_WEIGHT_OFFSET = 0; uint256 private constant _END_NORM_WEIGHT_OFFSET = _START_NORM_WEIGHT_OFFSET + _NORM_WEIGHT_WIDTH; uint256 private constant _DECIMAL_DIFF_OFFSET = _END_NORM_WEIGHT_OFFSET + _NORM_WEIGHT_WIDTH; uint256 private constant _NORM_WEIGHT_WIDTH = 64; uint256 private constant _DECIMAL_DIFF_WIDTH = 5; // Getters /** * @notice Returns the token's scaling factor. * @param tokenState - The byte32 state of the token of interest. */ function getTokenScalingFactor(bytes32 tokenState) internal pure returns (uint256) { uint256 decimalsDifference = tokenState.decodeUint(_DECIMAL_DIFF_OFFSET, _DECIMAL_DIFF_WIDTH); // This is equivalent to `10**(18+decimalsDifference)` but this form optimizes for 18 decimal tokens. return FixedPoint.ONE * 10**decimalsDifference; } /** * @notice Returns the token weight, interpolated between the starting and ending weights. * @param tokenState - The byte32 state of the token of interest. * @param pctProgress - A 18 decimal fixed-point value corresponding to how far to interpolate between the start * and end weights. 0 represents the start weight and 1 represents the end weight (with values >1 being clipped). */ function getTokenWeight(bytes32 tokenState, uint256 pctProgress) internal pure returns (uint256) { return GradualValueChange.interpolateValue( tokenState.decodeUint(_START_NORM_WEIGHT_OFFSET, _NORM_WEIGHT_WIDTH), tokenState.decodeUint(_END_NORM_WEIGHT_OFFSET, _NORM_WEIGHT_WIDTH), pctProgress ); } /** * @notice Returns the token's starting and ending weights. * @param tokenState - The byte32 state of the token of interest. * @return normalizedStartWeight - The starting normalized weight of the token. * @return normalizedEndWeight - The ending normalized weight of the token. */ function getTokenStartAndEndWeights(bytes32 tokenState) internal pure returns (uint256 normalizedStartWeight, uint256 normalizedEndWeight) { normalizedStartWeight = tokenState.decodeUint(_START_NORM_WEIGHT_OFFSET, _NORM_WEIGHT_WIDTH); normalizedEndWeight = tokenState.decodeUint(_END_NORM_WEIGHT_OFFSET, _NORM_WEIGHT_WIDTH); } // Setters /** * @notice Updates a token's starting and ending weights. * @dev Initiate a gradual weight change between the given starting and ending values. * @param tokenState - The byte32 state of the token of interest. * @param normalizedStartWeight - The current normalized weight of the token. * @param normalizedEndWeight - The desired final normalized weight of the token. */ function setTokenWeight( bytes32 tokenState, uint256 normalizedStartWeight, uint256 normalizedEndWeight ) internal pure returns (bytes32) { return tokenState.insertUint(normalizedStartWeight, _START_NORM_WEIGHT_OFFSET, _NORM_WEIGHT_WIDTH).insertUint( normalizedEndWeight, _END_NORM_WEIGHT_OFFSET, _NORM_WEIGHT_WIDTH ); } /** * @notice Writes the token's scaling factor into the token state. * @dev To save space, we store the scaling factor as the difference between 18 and the token's decimals, * and compute the "raw" scaling factor on the fly. * We segregated this function to avoid unnecessary external calls. Token decimals do not change, so we * only need to call this once per token: either from the constructor, for the initial set of tokens, or * when adding a new token. * @param tokenState - The byte32 state of the token of interest. * @param token - The ERC20 token of interest. */ function setTokenScalingFactor(bytes32 tokenState, IERC20 token) internal view returns (bytes32) { // Tokens that don't implement the `decimals` method are not supported. // Tokens with more than 18 decimals are not supported return tokenState.insertUint( uint256(18).sub(ERC20(address(token)).decimals()), _DECIMAL_DIFF_OFFSET, _DECIMAL_DIFF_WIDTH ); } /** * @notice Initializes the token state for a new token. * @dev Since weights must be fixed during add/remove operations, we only need to supply a single normalized weight. * @param token - The ERC20 token of interest. * @param normalizedWeight - The normalized weight of the token. */ function initializeTokenState(IERC20 token, uint256 normalizedWeight) internal view returns (bytes32 tokenState) { tokenState = setTokenScalingFactor(bytes32(0), token); tokenState = setTokenWeight(tokenState, normalizedWeight, normalizedWeight); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library ManagedPoolAddRemoveTokenLib { // ManagedPool weights and swap fees can change over time: these periods are expected to be long enough (e.g. days) // that any timestamp manipulation would achieve very little. // solhint-disable not-rely-on-time using FixedPoint for uint256; function _ensureNoWeightChange(bytes32 poolState) private view { (uint256 startTime, uint256 endTime) = ManagedPoolStorageLib.getWeightChangeFields(poolState); if (block.timestamp < endTime) { _revert( block.timestamp < startTime ? Errors.CHANGE_TOKENS_PENDING_WEIGHT_CHANGE : Errors.CHANGE_TOKENS_DURING_WEIGHT_CHANGE ); } } /** * @notice Adds a token to the Pool's list of tradeable tokens. * * @dev By adding a token to the Pool's composition, the weights of all other tokens will be decreased. The new * token will have no balance - it is up to the owner to provide some immediately after calling this function. * Note however that regular join functions will not work while the new token has no balance: the only way to * deposit an initial amount is by using an Asset Manager. * * Token addition is forbidden during a weight change, or if one is scheduled to happen in the future. * * @param vault - The address of the Balancer Vault. * @param poolId - The bytes32 poolId of the Pool which to add the token. * @param poolState - The byte32 state of the Pool. * @param currentTokens - The array of IERC20 tokens held in the Pool prior to adding the new token. * @param currentWeights - The array of token weights prior to adding the new token. * @param tokenToAdd - The ERC20 token to be added to the Pool. * @param assetManager - The Asset Manager for the token. * @param tokenToAddNormalizedWeight - The normalized weight of `token` relative to the other tokens in the Pool. * @return tokenToAddState - The bytes32 state of the token which has been added. * @return newTokens - The updated tokens array once the token has been added. * @return newWeights - The updated weights array once the token has been added. */ function addToken( IVault vault, bytes32 poolId, bytes32 poolState, IERC20[] memory currentTokens, uint256[] memory currentWeights, IERC20 tokenToAdd, address assetManager, uint256 tokenToAddNormalizedWeight ) external returns ( bytes32 tokenToAddState, IERC20[] memory newTokens, uint256[] memory newWeights ) { // BPT cannot be added using this mechanism: Composable Pools manage it via dedicated PoolRegistrationLib // functions. _require(tokenToAdd != IERC20(address(this)), Errors.ADD_OR_REMOVE_BPT); // Tokens cannot be added during or before a weight change, since a) adding a token already involves a weight // change and would override an existing one, and b) any previous weight changes would be incomplete since they // wouldn't include the new token. _ensureNoWeightChange(poolState); // We first register the token in the Vault. This makes the Pool enter an invalid state, since one of its tokens // has a balance of zero (making the invariant also zero). The Asset Manager must be used to deposit some // initial balance and restore regular operation. // // We don't need to check that the new token is not already in the Pool, as the Vault will simply revert if we // try to register it again. PoolRegistrationLib.registerToken(vault, poolId, tokenToAdd, assetManager); // Once we've updated the state in the Vault, we need to also update our own state. This is a two-step process, // since we need to: // a) initialize the state of the new token // b) adjust the weights of all other tokens // Initializing the new token is straightforward. The Pool itself doesn't track how many or which tokens it uses // (and relies instead on the Vault for this), so we simply store the new token-specific information. // Note that we don't need to check here that the weight is valid as this is enforced when updating the weights. tokenToAddState = ManagedPoolTokenStorageLib.initializeTokenState(tokenToAdd, tokenToAddNormalizedWeight); // Adjusting the weights is a bit more involved however. We need to reduce all other weights to make room for // the new one. This is achieved by multipliyng them by a factor of `1 - new token weight`. // For example, if a 0.25/0.75 Pool gets added a token with a weight of 0.80, the final weights would be // 0.05/0.15/0.80, where 0.05 = 0.25 * (1 - 0.80) and 0.15 = 0.75 * (1 - 0.80). uint256 newWeightSum = 0; newTokens = new IERC20[](currentTokens.length + 1); newWeights = new uint256[](currentWeights.length + 1); for (uint256 i = 0; i < currentWeights.length; ++i) { newTokens[i] = currentTokens[i]; newWeights[i] = currentWeights[i].mulDown(FixedPoint.ONE.sub(tokenToAddNormalizedWeight)); newWeightSum = newWeightSum.add(newWeights[i]); } // Newly added tokens are always appended to the end of the existing array. newTokens[newTokens.length - 1] = tokenToAdd; // At this point `newWeights` contains the updated weights for all tokens other than the token to be added. // We could naively write `tokenToAddNormalizedWeight` into the last element of the `newWeights` array however, // it is possible that the new weights don't add up to 100% due to rounding errors - the sum might be slightly // smaller since we round the weights down. Due to this, we adjust the last weight so that the sum is exact. // // This error is negligible, since the error introduced in the weight of the last token equals the number of // tokens in the worst case (as each weight can be off by one at most), and the minimum weight is 1e16, meaning // there's ~15 orders of magnitude between the smallest weight and the error. It is important however that the // weights do add up to 100% exactly, as that property is relied on in some parts of the WeightedMath // computations. newWeights[newWeights.length - 1] = FixedPoint.ONE.sub(newWeightSum); } /** * @notice Removes a token from the Pool's list of tradeable tokens. * @dev Tokens can only be removed if the Pool has more than 2 tokens, as it can never have fewer than 2. * * Token removal is also forbidden during a weight change, or if one is scheduled to happen in the future. * * @param vault - The address of the Balancer Vault. * @param poolId - The bytes32 poolId of the Pool which to add the token. * @param poolState - The byte32 state of the Pool. * @param currentTokens - The array of IERC20 tokens held in the Pool prior to adding the new token. * @param currentWeights - The array of token weights prior to adding the new token. * @param tokenToRemove - The ERC20 token to be removed from the Pool. * @param tokenToRemoveNormalizedWeight - The normalized weight of `tokenToRemove`. * @return newTokens - The updated tokens array once the token has been removed. * @return newWeights - The updated weights array once the token has been removed. */ function removeToken( IVault vault, bytes32 poolId, bytes32 poolState, IERC20[] memory currentTokens, uint256[] memory currentWeights, IERC20 tokenToRemove, uint256 tokenToRemoveNormalizedWeight ) external returns (IERC20[] memory newTokens, uint256[] memory newWeights) { // BPT cannot be removed using this mechanism: Composable Pools manage it via dedicated PoolRegistrationLib // functions. _require(tokenToRemove != IERC20(address(this)), Errors.ADD_OR_REMOVE_BPT); // Tokens cannot be removed during or before a weight change, since a) removing a token already involves a // weight change and would override an existing one, and b) any previous weight changes would be incorrect since // they would include the removed token. _ensureNoWeightChange(poolState); // Before this function is called, the caller must have withdrawn all balance for `token` from the Pool. This // means that the Pool is in an invalid state, since among other things the invariant is zero. Because we're not // in a valid state and all value-changing operations will revert, we are free to modify the Pool state (e.g. // alter weights). // // We don't need to test the zero balance since the Vault will simply revert on deregistration if this is not // the case, or if the token is not currently registered. PoolRegistrationLib.deregisterToken(vault, poolId, tokenToRemove); // Once we've updated the state in the Vault, we need to also update our own state. This is a two-step process, // since we need to: // a) delete the state of the removed token // b) adjust the weights of all other tokens // Adjusting the weights is a bit more involved however. We need to increase all other weights so that they add // up to 100%. This is achieved by dividing them by a factor of `1 - old token weight`. // For example, if a 0.05/0.15/0.80 Pool has its 80% token removed, the final weights would be 0.25/0.75, where // 0.25 = 0.05 / (1 - 0.80) and 0.75 = 0.15 / (1 - 0.80). uint256 newWeightSum = 0; newTokens = new IERC20[](currentTokens.length - 1); newWeights = new uint256[](currentWeights.length - 1); for (uint256 i = 0; i < newWeights.length; ++i) { if (currentTokens[i] == tokenToRemove) { // If we're at the index of the removed token then want to instead insert the weight of the final token. // This is because the token at the end of the array will be moved into the index of the removed token // in a "swap and pop" operation. newTokens[i] = currentTokens[currentTokens.length - 1]; newWeights[i] = currentWeights[currentWeights.length - 1].divDown( FixedPoint.ONE.sub(tokenToRemoveNormalizedWeight) ); } else { newTokens[i] = currentTokens[i]; newWeights[i] = currentWeights[i].divDown(FixedPoint.ONE.sub(tokenToRemoveNormalizedWeight)); } newWeightSum = newWeightSum.add(newWeights[i]); } // It is possible that the new weights don't add up to 100% due to rounding errors - the sum might be slightly // smaller since we round the weights down. In that case, we adjust the last weight so that the sum is exact. // // This error is negligible, since the error introduced in the weight of the last token equals the number of // tokens in the worst case (as each weight can be off by one at most), and the minimum weight is 1e16, meaning // there's ~15 orders of magnitude between the smallest weight and the error. It is important however that the // weights do add up to 100% exactly, as that property is relied on in some parts of the WeightedMath // computations. if (newWeightSum != FixedPoint.ONE) { newWeights[newWeights.length - 1] = newWeights[newWeights.length - 1].add(FixedPoint.ONE.sub(newWeightSum)); } } } /** * @title Managed Pool Settings */ abstract contract ManagedPoolSettings is NewBasePool, ProtocolFeeCache, IManagedPool { // ManagedPool weights and swap fees can change over time: these periods are expected to be long enough (e.g. days) // that any timestamp manipulation would achieve very little. // solhint-disable not-rely-on-time using FixedPoint for uint256; using WeightedPoolUserData for bytes; // State variables uint256 private constant _MIN_TOKENS = 2; // The upper bound is WeightedMath.MAX_WEIGHTED_TOKENS, but this is constrained by other factors, such as Pool // creation gas consumption. uint256 private constant _MAX_TOKENS = 50; // The swap fee cannot be 100%: calculations that divide by (1-fee) would revert with division by zero. // Swap fees close to 100% can still cause reverts when performing join/exit swaps, if the calculated fee // amounts exceed the pool's token balances in the Vault. 95% is a very high but safe maximum value, and we want to // be permissive to let the owner manage the Pool as they see fit. uint256 private constant _MAX_SWAP_FEE_PERCENTAGE = 95e16; // 95% // The same logic applies to the AUM fee. uint256 private constant _MAX_MANAGEMENT_AUM_FEE_PERCENTAGE = 95e16; // 95% // We impose a minimum swap fee to create some buy/sell spread, and prevent the Pool from being drained through // repeated interactions. We should not need this since we explicity always round favoring the Pool, but a minimum // swap fee adds an extra safeguard. uint256 private constant _MIN_SWAP_FEE_PERCENTAGE = 1e12; // 0.0001% // Stores commonly used Pool state. // This slot is preferred for gas-sensitive operations as it is read in all joins, swaps and exits, // and therefore warm. // See `ManagedPoolStorageLib.sol` for data layout. bytes32 private _poolState; // Stores state related to charging AUM fees. // See `ManagedPoolAUMStorageLib.sol` for data layout. bytes32 private _aumState; // Store scaling factor and start/end normalized weights for each token. // See `ManagedPoolTokenStorageLib.sol` for data layout. mapping(IERC20 => bytes32) private _tokenState; // Store the circuit breaker configuration for each token. // See `CircuitBreakerStorageLib.sol` for data layout. mapping(IERC20 => bytes32) private _circuitBreakerState; // If mustAllowlistLPs is enabled, this is the list of addresses allowed to join the pool mapping(address => bool) private _allowedAddresses; struct ManagedPoolSettingsParams { IERC20[] tokens; uint256[] normalizedWeights; uint256 swapFeePercentage; bool swapEnabledOnStart; bool mustAllowlistLPs; uint256 managementAumFeePercentage; uint256 aumFeeId; } constructor(ManagedPoolSettingsParams memory params, IProtocolFeePercentagesProvider protocolFeeProvider) ProtocolFeeCache( protocolFeeProvider, ProviderFeeIDs({ swap: ProtocolFeeType.SWAP, yield: ProtocolFeeType.YIELD, aum: params.aumFeeId }) ) { uint256 totalTokens = params.tokens.length; _require(totalTokens >= _MIN_TOKENS, Errors.MIN_TOKENS); _require(totalTokens <= _MAX_TOKENS, Errors.MAX_TOKENS); InputHelpers.ensureInputLengthMatch(totalTokens, params.normalizedWeights.length); // Validate and set initial fees _setManagementAumFeePercentage(params.managementAumFeePercentage); // Initialize the tokens' states with their scaling factors and weights. for (uint256 i = 0; i < totalTokens; i++) { IERC20 token = params.tokens[i]; _tokenState[token] = ManagedPoolTokenStorageLib.initializeTokenState(token, params.normalizedWeights[i]); } // This is technically a noop with regards to the tokens' weights in storage. However, it performs important // validation of the token weights (normalization / bounds checking), and emits an event for offchain services. _startGradualWeightChange( block.timestamp, block.timestamp, params.normalizedWeights, params.normalizedWeights, params.tokens ); _startGradualSwapFeeChange( block.timestamp, block.timestamp, params.swapFeePercentage, params.swapFeePercentage ); // If false, the pool will start in the disabled state (prevents front-running the enable swaps transaction). _setSwapEnabled(params.swapEnabledOnStart); // If true, only addresses on the manager-controlled allowlist may join the pool. _setMustAllowlistLPs(params.mustAllowlistLPs); // Joins and exits are enabled by default on start. _setJoinExitEnabled(true); } function _getPoolState() internal view returns (bytes32) { return _poolState; } function _getTokenState(IERC20 token) internal view returns (bytes32) { return _tokenState[token]; } function _getCircuitBreakerState(IERC20 token) internal view returns (bytes32) { return _circuitBreakerState[token]; } // Virtual Supply /** * @notice Returns the number of tokens in circulation. * @dev For the majority of Pools, this will simply be a wrapper around the `totalSupply` function. However, * composable pools premint a large fraction of the BPT supply and place it in the Vault. In this situation, * the override would subtract this BPT balance from the total to reflect the actual amount of BPT in circulation. */ function _getVirtualSupply() internal view virtual returns (uint256); // Actual Supply function getActualSupply() external view override returns (uint256) { return _getActualSupply(_getVirtualSupply()); } function _getActualSupply(uint256 virtualSupply) internal view returns (uint256) { (uint256 aumFeePercentage, uint256 lastCollectionTimestamp) = getManagementAumFeeParams(); uint256 aumFeesAmount = ExternalAUMFees.getAumFeesBptAmount( virtualSupply, block.timestamp, lastCollectionTimestamp, aumFeePercentage ); return virtualSupply.add(aumFeesAmount); } // Swap fees /** * @notice Returns the current value of the swap fee percentage. * @dev Computes the current swap fee percentage, which can change every block if a gradual swap fee * update is in progress. */ function getSwapFeePercentage() external view override returns (uint256) { return ManagedPoolStorageLib.getSwapFeePercentage(_poolState); } function getGradualSwapFeeUpdateParams() external view override returns ( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) { return ManagedPoolStorageLib.getSwapFeeFields(_poolState); } function updateSwapFeeGradually( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) external override authenticate whenNotPaused { _startGradualSwapFeeChange( GradualValueChange.resolveStartTime(startTime, endTime), endTime, startSwapFeePercentage, endSwapFeePercentage ); } function _validateSwapFeePercentage(uint256 swapFeePercentage) internal pure { _require(swapFeePercentage >= _MIN_SWAP_FEE_PERCENTAGE, Errors.MIN_SWAP_FEE_PERCENTAGE); _require(swapFeePercentage <= _MAX_SWAP_FEE_PERCENTAGE, Errors.MAX_SWAP_FEE_PERCENTAGE); } /** * @notice Encodes a gradual swap fee update into the Pool state in storage. * @param startTime - The timestamp when the swap fee change will begin. * @param endTime - The timestamp when the swap fee change will end (must be >= startTime). * @param startSwapFeePercentage - The starting value for the swap fee change. * @param endSwapFeePercentage - The ending value for the swap fee change. If the current timestamp >= endTime, * `getSwapFeePercentage()` will return this value. */ function _startGradualSwapFeeChange( uint256 startTime, uint256 endTime, uint256 startSwapFeePercentage, uint256 endSwapFeePercentage ) internal { _validateSwapFeePercentage(startSwapFeePercentage); _validateSwapFeePercentage(endSwapFeePercentage); _poolState = ManagedPoolStorageLib.setSwapFeeData( _poolState, startTime, endTime, startSwapFeePercentage, endSwapFeePercentage ); emit GradualSwapFeeUpdateScheduled(startTime, endTime, startSwapFeePercentage, endSwapFeePercentage); } // Token weights /** * @dev Returns all normalized weights, in the same order as the Pool's tokens. */ function _getNormalizedWeights(IERC20[] memory tokens) internal view returns (uint256[] memory normalizedWeights) { uint256 weightChangeProgress = ManagedPoolStorageLib.getGradualWeightChangeProgress(_poolState); uint256 numTokens = tokens.length; normalizedWeights = new uint256[](numTokens); for (uint256 i = 0; i < numTokens; i++) { normalizedWeights[i] = ManagedPoolTokenStorageLib.getTokenWeight( _tokenState[tokens[i]], weightChangeProgress ); } } function getNormalizedWeights() external view override returns (uint256[] memory) { (IERC20[] memory tokens, ) = _getPoolTokens(); return _getNormalizedWeights(tokens); } /** * @dev Returns the normalized weight of a single token. */ function _getNormalizedWeight(IERC20 token) internal view returns (uint256) { return ManagedPoolTokenStorageLib.getTokenWeight( _tokenState[token], ManagedPoolStorageLib.getGradualWeightChangeProgress(_poolState) ); } function getGradualWeightUpdateParams() external view override returns ( uint256 startTime, uint256 endTime, uint256[] memory startWeights, uint256[] memory endWeights ) { (startTime, endTime) = ManagedPoolStorageLib.getWeightChangeFields(_poolState); (IERC20[] memory tokens, ) = _getPoolTokens(); startWeights = new uint256[](tokens.length); endWeights = new uint256[](tokens.length); for (uint256 i = 0; i < tokens.length; i++) { (startWeights[i], endWeights[i]) = ManagedPoolTokenStorageLib.getTokenStartAndEndWeights( _tokenState[tokens[i]] ); } } function updateWeightsGradually( uint256 startTime, uint256 endTime, IERC20[] memory tokens, uint256[] memory endWeights ) external override authenticate whenNotPaused { (IERC20[] memory actualTokens, ) = _getPoolTokens(); InputHelpers.ensureInputLengthMatch(tokens.length, actualTokens.length, endWeights.length); for (uint256 i = 0; i < actualTokens.length; ++i) { _require(actualTokens[i] == tokens[i], Errors.TOKENS_MISMATCH); } _startGradualWeightChange( GradualValueChange.resolveStartTime(startTime, endTime), endTime, _getNormalizedWeights(tokens), endWeights, tokens ); } /** * @dev Validate the end weights, and set the start weights. `updateWeightsGradually` passes in the current weights * as the start weights, so that calling updateWeightsGradually again during an update will not result in any * abrupt weight changes. Also update the pool state with the start and end times. */ function _startGradualWeightChange( uint256 startTime, uint256 endTime, uint256[] memory startWeights, uint256[] memory endWeights, IERC20[] memory tokens ) internal { uint256 normalizedSum; for (uint256 i = 0; i < endWeights.length; i++) { uint256 endWeight = endWeights[i]; _require(endWeight >= WeightedMath._MIN_WEIGHT, Errors.MIN_WEIGHT); normalizedSum = normalizedSum.add(endWeight); IERC20 token = tokens[i]; _tokenState[token] = ManagedPoolTokenStorageLib.setTokenWeight( _tokenState[token], startWeights[i], endWeight ); } // Ensure that the normalized weights sum to ONE _require(normalizedSum == FixedPoint.ONE, Errors.NORMALIZED_WEIGHT_INVARIANT); _poolState = ManagedPoolStorageLib.setWeightChangeData(_poolState, startTime, endTime); emit GradualWeightUpdateScheduled(startTime, endTime, startWeights, endWeights); } // Join / Exit Enabled function getJoinExitEnabled() external view override returns (bool) { return ManagedPoolStorageLib.getJoinExitEnabled(_poolState); } function setJoinExitEnabled(bool joinExitEnabled) external override authenticate whenNotPaused { _setJoinExitEnabled(joinExitEnabled); } function _setJoinExitEnabled(bool joinExitEnabled) private { _poolState = ManagedPoolStorageLib.setJoinExitEnabled(_poolState, joinExitEnabled); emit JoinExitEnabledSet(joinExitEnabled); } // Swap Enabled function getSwapEnabled() external view override returns (bool) { return ManagedPoolStorageLib.getSwapEnabled(_poolState); } function setSwapEnabled(bool swapEnabled) external override authenticate whenNotPaused { _setSwapEnabled(swapEnabled); } function _setSwapEnabled(bool swapEnabled) private { _poolState = ManagedPoolStorageLib.setSwapEnabled(_poolState, swapEnabled); emit SwapEnabledSet(swapEnabled); } // LP Allowlist function getMustAllowlistLPs() external view override returns (bool) { return ManagedPoolStorageLib.getLPAllowlistEnabled(_poolState); } /** * @notice Check whether an LP address is on the allowlist. * @dev This simply checks the list, regardless of whether the allowlist feature is enabled, so that the allowlist * can be inspected at any time. * @param member - The address to check against the allowlist. * @return true if the given address is on the allowlist. */ function isAddressOnAllowlist(address member) public view override returns (bool) { return _allowedAddresses[member]; } /** * @notice Check an LP address against the allowlist. * @dev If the allowlist is not enabled, this returns true for every address. * @param poolState - The bytes32 representing the state of the pool. * @param member - The address to check against the allowlist. * @return - Whether the given address is allowed to join the pool. */ function _isAllowedAddress(bytes32 poolState, address member) internal view returns (bool) { return !ManagedPoolStorageLib.getLPAllowlistEnabled(poolState) || isAddressOnAllowlist(member); } function addAllowedAddress(address member) external override authenticate whenNotPaused { _require(!isAddressOnAllowlist(member), Errors.ADDRESS_ALREADY_ALLOWLISTED); _allowedAddresses[member] = true; emit AllowlistAddressAdded(member); } function removeAllowedAddress(address member) external override authenticate whenNotPaused { _require(isAddressOnAllowlist(member), Errors.ADDRESS_NOT_ALLOWLISTED); delete _allowedAddresses[member]; emit AllowlistAddressRemoved(member); } function setMustAllowlistLPs(bool mustAllowlistLPs) external override authenticate whenNotPaused { _setMustAllowlistLPs(mustAllowlistLPs); } function _setMustAllowlistLPs(bool mustAllowlistLPs) private { _poolState = ManagedPoolStorageLib.setLPAllowlistEnabled(_poolState, mustAllowlistLPs); emit MustAllowlistLPsSet(mustAllowlistLPs); } // AUM management fees function getManagementAumFeeParams() public view override returns (uint256 aumFeePercentage, uint256 lastCollectionTimestamp) { (aumFeePercentage, lastCollectionTimestamp) = ManagedPoolAumStorageLib.getAumFeeFields(_aumState); // If we're in recovery mode, set the fee percentage to zero so that we bypass any fee logic that might fail // and prevent LPs from exiting the pool. if (ManagedPoolStorageLib.getRecoveryModeEnabled(_poolState)) { aumFeePercentage = 0; } } function setManagementAumFeePercentage(uint256 managementAumFeePercentage) external override authenticate whenNotPaused returns (uint256 amount) { // We want to prevent the pool manager from retroactively increasing the amount of AUM fees payable. // To prevent this, we perform a collection before updating the fee percentage. // This is only necessary if the pool has been initialized (which is indicated by a nonzero total supply). uint256 supplyBeforeFeeCollection = _getVirtualSupply(); if (supplyBeforeFeeCollection > 0) { amount = _collectAumManagementFees(supplyBeforeFeeCollection); } _setManagementAumFeePercentage(managementAumFeePercentage); } function _setManagementAumFeePercentage(uint256 managementAumFeePercentage) private { _require( managementAumFeePercentage <= _MAX_MANAGEMENT_AUM_FEE_PERCENTAGE, Errors.MAX_MANAGEMENT_AUM_FEE_PERCENTAGE ); _aumState = ManagedPoolAumStorageLib.setAumFeePercentage(_aumState, managementAumFeePercentage); emit ManagementAumFeePercentageChanged(managementAumFeePercentage); } /** * @notice Stores the current timestamp as the most recent collection of AUM fees. * @dev This function *must* be called after each collection of AUM fees. */ function _updateAumFeeCollectionTimestamp() internal { _aumState = ManagedPoolAumStorageLib.setLastCollectionTimestamp(_aumState, block.timestamp); } function collectAumManagementFees() external override whenNotPaused returns (uint256) { // It only makes sense to collect AUM fees after the pool is initialized (as before then the AUM is zero). // We can query if the pool is initialized by checking for a nonzero total supply. // Reverting here prevents zero value AUM fee collections causing bogus events. uint256 supply = _getVirtualSupply(); _require(supply > 0, Errors.UNINITIALIZED); return _collectAumManagementFees(supply); } /** * @notice Calculates the AUM fees accrued since the last collection and pays it to the pool manager. * @dev The AUM fee calculation is based on inflating the Pool's BPT supply by a target rate. This assumes * a constant virtual supply between fee collections. To ensure proper accounting, we must therefore collect * AUM fees whenever the virtual supply of the Pool changes. * * This collection mints the difference between the virtual supply and the actual supply. By adding the amount of * BPT returned by this function to the virtual supply passed in, we may calculate the updated virtual supply * (which is equal to the actual supply). * @return bptAmount - The amount of BPT minted as AUM fees. */ function _collectAumManagementFees(uint256 virtualSupply) internal returns (uint256) { (uint256 aumFeePercentage, uint256 lastCollectionTimestamp) = getManagementAumFeeParams(); uint256 bptAmount = ExternalAUMFees.getAumFeesBptAmount( virtualSupply, block.timestamp, lastCollectionTimestamp, aumFeePercentage ); // We always update last collection timestamp even when there is nothing to collect to ensure the state is kept // consistent. _updateAumFeeCollectionTimestamp(); // Early return if either: // - AUM fee is disabled. // - no time has passed since the last collection. if (bptAmount == 0) { return 0; } // Split AUM fees between protocol and Pool manager. In low liquidity situations, rounding may result in a // managerBPTAmount of zero. In general, when splitting fees, LPs come first, followed by the protocol, // followed by the manager. uint256 protocolBptAmount = bptAmount.mulUp(getProtocolFeePercentageCache(ProtocolFeeType.AUM)); uint256 managerBPTAmount = bptAmount.sub(protocolBptAmount); _payProtocolFees(protocolBptAmount); emit ManagementAumFeeCollected(managerBPTAmount); _mintPoolTokens(getOwner(), managerBPTAmount); return bptAmount; } // Add/Remove tokens function addToken( IERC20 tokenToAdd, address assetManager, uint256 tokenToAddNormalizedWeight, uint256 mintAmount, address recipient ) external override authenticate whenNotPaused { { // This complex operation might mint BPT, altering the supply. For simplicity, we forbid adding tokens // before initialization (i.e. before BPT is first minted). We must also collect AUM fees every time the // BPT supply changes. For consistency, we do this always, even if the amount to mint is zero. uint256 supply = _getVirtualSupply(); _require(supply > 0, Errors.UNINITIALIZED); _collectAumManagementFees(supply); } (IERC20[] memory tokens, ) = _getPoolTokens(); _require(tokens.length + 1 <= _MAX_TOKENS, Errors.MAX_TOKENS); // `ManagedPoolAddRemoveTokenLib.addToken` performs any necessary state updates in the Vault and returns // values necessary for the Pool to update its own state. (bytes32 tokenToAddState, IERC20[] memory newTokens, uint256[] memory newWeights) = ManagedPoolAddRemoveTokenLib .addToken( getVault(), getPoolId(), _poolState, tokens, _getNormalizedWeights(tokens), tokenToAdd, assetManager, tokenToAddNormalizedWeight ); // Once we've updated the state in the Vault, we also need to update our own state. This is a two-step process, // since we need to: // a) initialize the state of the new token // b) adjust the weights of all other tokens // Initializing the new token is straightforward. The Pool itself doesn't track how many or which tokens it uses // (and relies instead on the Vault for this), so we simply store the new token-specific information. // Note that we don't need to check here that the weight is valid. We'll later call `_startGradualWeightChange`, // which will check the entire set of weights for correctness. _tokenState[tokenToAdd] = tokenToAddState; // `_startGradualWeightChange` will perform all required validation on the new weights, including minimum // weights, sum, etc., so we don't need to worry about that ourselves. // Note that this call will set the weight for `tokenToAdd`, which we've already done - that'll just be a no-op. _startGradualWeightChange(block.timestamp, block.timestamp, newWeights, newWeights, newTokens); if (mintAmount > 0) { _mintPoolTokens(recipient, mintAmount); } emit TokenAdded(tokenToAdd, tokenToAddNormalizedWeight); } function removeToken( IERC20 tokenToRemove, uint256 burnAmount, address sender ) external override authenticate whenNotPaused { { // Add new scope to avoid stack too deep. // This complex operation might burn BPT, altering the supply. For simplicity, we forbid removing tokens // before initialization (i.e. before BPT is first minted). We must also collect AUM fees every time the // BPT supply changes. For consistency, we do this always, even if the amount to burn is zero. uint256 supply = _getVirtualSupply(); _require(supply > 0, Errors.UNINITIALIZED); _collectAumManagementFees(supply); } (IERC20[] memory tokens, ) = _getPoolTokens(); _require(tokens.length - 1 >= 2, Errors.MIN_TOKENS); // Token removal is forbidden during a weight change or if one is scheduled so we can assume that // the weight change progress is 100%. uint256 tokenToRemoveNormalizedWeight = ManagedPoolTokenStorageLib.getTokenWeight( _tokenState[tokenToRemove], FixedPoint.ONE ); // `ManagedPoolAddRemoveTokenLib.removeToken` performs any necessary state updates in the Vault and returns // values necessary for the Pool to update its own state. (IERC20[] memory newTokens, uint256[] memory newWeights) = ManagedPoolAddRemoveTokenLib.removeToken( getVault(), getPoolId(), _poolState, tokens, _getNormalizedWeights(tokens), tokenToRemove, tokenToRemoveNormalizedWeight ); // Once we've updated the state in the Vault, we also need to update our own state. This is a two-step process, // since we need to: // a) delete the state of the removed token // b) adjust the weights of all other tokens // Deleting the old token is straightforward. The Pool itself doesn't track how many or which tokens it uses // (and relies instead on the Vault for this), so we simply delete the token-specific information. delete _tokenState[tokenToRemove]; // `_startGradualWeightChange` will perform all required validation on the new weights, including minimum // weights, sum, etc., so we don't need to worry about that ourselves. _startGradualWeightChange(block.timestamp, block.timestamp, newWeights, newWeights, newTokens); if (burnAmount > 0) { // We disallow burning from the zero address, as that would allow potentially returning the Pool to the // uninitialized state. _require(sender != address(0), Errors.BURN_FROM_ZERO); _burnPoolTokens(sender, burnAmount); } // The Pool is now again in a valid state: by the time the zero valued token is deregistered, all internal Pool // state is updated. emit TokenRemoved(tokenToRemove); } // Scaling Factors function getScalingFactors() external view override returns (uint256[] memory) { (IERC20[] memory tokens, ) = _getPoolTokens(); return _scalingFactors(tokens); } function _scalingFactors(IERC20[] memory tokens) internal view returns (uint256[] memory scalingFactors) { uint256 numTokens = tokens.length; scalingFactors = new uint256[](numTokens); for (uint256 i = 0; i < numTokens; i++) { scalingFactors[i] = ManagedPoolTokenStorageLib.getTokenScalingFactor(_tokenState[tokens[i]]); } } // Protocol Fee Cache /** * @dev Pays any due protocol and manager fees before updating the cached protocol fee percentages. */ function _beforeProtocolFeeCacheUpdate() internal override { // We pay any due protocol or manager fees *before* updating the cache. This ensures that the new // percentages only affect future operation of the Pool, and not past fees. // Given that this operation is state-changing and relatively complex, we only allow it as long as the Pool is // not paused. _ensureNotPaused(); // We skip fee collection until the Pool is initialized. uint256 supplyBeforeFeeCollection = _getVirtualSupply(); if (supplyBeforeFeeCollection > 0) { _collectAumManagementFees(supplyBeforeFeeCollection); } } // Recovery Mode /** * @notice Returns whether the pool is in Recovery Mode. */ function inRecoveryMode() public view override returns (bool) { return ManagedPoolStorageLib.getRecoveryModeEnabled(_poolState); } /** * @dev Sets the recoveryMode state, and emits the corresponding event. */ function _setRecoveryMode(bool enabled) internal override { _poolState = ManagedPoolStorageLib.setRecoveryModeEnabled(_poolState, enabled); // Some pools need to update their state when leaving recovery mode to ensure proper functioning of the Pool. // We do not perform any state updates when entering recovery mode, as this may jeopardize the ability to // enable Recovery mode. if (!enabled) { // Recovery mode exits bypass the AUM fee calculation. This means that if the Pool is paused and in // Recovery mode for a period of time, then later returns to normal operation, AUM fees will be charged // to the remaining LPs for the full period. We then update the collection timestamp so that no AUM fees // are accrued over this period. _updateAumFeeCollectionTimestamp(); } } // Circuit Breakers function getCircuitBreakerState(IERC20 token) external view override returns ( uint256 bptPrice, uint256 referenceWeight, uint256 lowerBound, uint256 upperBound, uint256 lowerBptPriceBound, uint256 upperBptPriceBound ) { bytes32 circuitBreakerState = _circuitBreakerState[token]; (bptPrice, referenceWeight, lowerBound, upperBound) = CircuitBreakerStorageLib.getCircuitBreakerFields( circuitBreakerState ); uint256 normalizedWeight = _getNormalizedWeight(token); lowerBptPriceBound = CircuitBreakerStorageLib.getBptPriceBound(circuitBreakerState, normalizedWeight, true); upperBptPriceBound = CircuitBreakerStorageLib.getBptPriceBound(circuitBreakerState, normalizedWeight, false); // Restore the original unscaled BPT price passed in `setCircuitBreakers`. uint256 tokenScalingFactor = ManagedPoolTokenStorageLib.getTokenScalingFactor(_getTokenState(token)); bptPrice = _upscale(bptPrice, tokenScalingFactor); // Also render the adjusted bounds as unscaled values. lowerBptPriceBound = _upscale(lowerBptPriceBound, tokenScalingFactor); upperBptPriceBound = _upscale(upperBptPriceBound, tokenScalingFactor); } function setCircuitBreakers( IERC20[] memory tokens, uint256[] memory bptPrices, uint256[] memory lowerBoundPercentages, uint256[] memory upperBoundPercentages ) external override authenticate whenNotPaused { InputHelpers.ensureInputLengthMatch(tokens.length, lowerBoundPercentages.length, upperBoundPercentages.length); InputHelpers.ensureInputLengthMatch(tokens.length, bptPrices.length); for (uint256 i = 0; i < tokens.length; i++) { _setCircuitBreaker(tokens[i], bptPrices[i], lowerBoundPercentages[i], upperBoundPercentages[i]); } } // Compute the reference values, then pass them along with the bounds to the library. The bptPrice must be // passed in from the caller, or it would be manipulable. We assume the bptPrice from the caller was computed // using the native (i.e., unscaled) token balance. function _setCircuitBreaker( IERC20 token, uint256 bptPrice, uint256 lowerBoundPercentage, uint256 upperBoundPercentage ) private { uint256 normalizedWeight = _getNormalizedWeight(token); // Fail if the token is not in the pool (or is the BPT token) _require(normalizedWeight != 0, Errors.INVALID_TOKEN); // The incoming BPT price (defined as actualSupply * weight / balance) will have been calculated dividing // by unscaled token balance, effectively multiplying the result by the scaling factor. // To correct this, we need to divide by it (downscaling). uint256 scaledBptPrice = _downscaleDown( bptPrice, ManagedPoolTokenStorageLib.getTokenScalingFactor(_getTokenState(token)) ); // The library will validate the lower/upper bounds _circuitBreakerState[token] = CircuitBreakerStorageLib.setCircuitBreaker( scaledBptPrice, normalizedWeight, lowerBoundPercentage, upperBoundPercentage ); // Echo the unscaled BPT price in the event. emit CircuitBreakerSet(token, bptPrice, lowerBoundPercentage, upperBoundPercentage); } // Misc /** * @dev Enumerates all ownerOnly functions in Managed Pool. */ function _isOwnerOnlyAction(bytes32 actionId) internal view override returns (bool) { return (actionId == getActionId(ManagedPoolSettings.updateWeightsGradually.selector)) || (actionId == getActionId(ManagedPoolSettings.updateSwapFeeGradually.selector)) || (actionId == getActionId(ManagedPoolSettings.setJoinExitEnabled.selector)) || (actionId == getActionId(ManagedPoolSettings.setSwapEnabled.selector)) || (actionId == getActionId(ManagedPoolSettings.addAllowedAddress.selector)) || (actionId == getActionId(ManagedPoolSettings.removeAllowedAddress.selector)) || (actionId == getActionId(ManagedPoolSettings.setMustAllowlistLPs.selector)) || (actionId == getActionId(ManagedPoolSettings.addToken.selector)) || (actionId == getActionId(ManagedPoolSettings.removeToken.selector)) || (actionId == getActionId(ManagedPoolSettings.setManagementAumFeePercentage.selector)) || (actionId == getActionId(ManagedPoolSettings.setCircuitBreakers.selector)); } /** * @notice Returns the tokens in the Pool and their current balances. * @dev This function must be overridden to process these arrays according to the specific pool type. * A common example of this is in composable pools, as we may need to drop the BPT token and its balance. */ function _getPoolTokens() internal view virtual returns (IERC20[] memory tokens, uint256[] memory balances); } /** * @title Managed Pool * @dev Weighted Pool with mutable tokens and weights, designed to be used in conjunction with a contract * (as the owner, containing any specific business logic). Since the pool itself permits "dangerous" * operations, it should never be deployed with an EOA as the owner. * * The owner contract can impose arbitrary access control schemes on its permissions: it might allow a multisig * to add or remove tokens, and let an EOA set the swap fees. * * Pool owners can also serve as intermediate contracts to hold tokens, deploy timelocks, consult with * other protocols or on-chain oracles, or bundle several operations into one transaction that re-entrancy * protection would prevent initiating from the pool contract. * * Managed Pools are designed to support many asset management use cases, including: large token counts, * rebalancing through token changes, gradual weight or fee updates, fine-grained control of protocol and * management fees, allowlisting of LPs, and more. */ contract ManagedPool is IVersion, ManagedPoolSettings { // ManagedPool weights and swap fees can change over time: these periods are expected to be long enough (e.g. days) // that any timestamp manipulation would achieve very little. // solhint-disable not-rely-on-time using FixedPoint for uint256; using BasePoolUserData for bytes; using WeightedPoolUserData for bytes; // The maximum imposed by the Vault, which stores balances in a packed format, is 2**(112) - 1. // We are only minting half of the maximum value - already an amount many orders of magnitude greater than any // conceivable real liquidity - to allow for minting new BPT as a result of regular joins. uint256 private constant _PREMINTED_TOKEN_BALANCE = 2**(111); IExternalWeightedMath private immutable _weightedMath; string private _version; struct ManagedPoolParams { string name; string symbol; address[] assetManagers; } struct ManagedPoolConfigParams { IVault vault; IProtocolFeePercentagesProvider protocolFeeProvider; IExternalWeightedMath weightedMath; uint256 pauseWindowDuration; uint256 bufferPeriodDuration; string version; } constructor( ManagedPoolParams memory params, ManagedPoolConfigParams memory configParams, ManagedPoolSettingsParams memory settingsParams, address owner ) NewBasePool( configParams.vault, PoolRegistrationLib.registerComposablePool( configParams.vault, IVault.PoolSpecialization.MINIMAL_SWAP_INFO, settingsParams.tokens, params.assetManagers ), params.name, params.symbol, configParams.pauseWindowDuration, configParams.bufferPeriodDuration, owner ) ManagedPoolSettings(settingsParams, configParams.protocolFeeProvider) { _weightedMath = configParams.weightedMath; _version = configParams.version; } function version() external view override returns (string memory) { return _version; } function _getWeightedMath() internal view returns (IExternalWeightedMath) { return _weightedMath; } // Virtual Supply /** * @notice Returns the number of tokens in circulation. * @dev In other pools, this would be the same as `totalSupply`, but since this pool pre-mints BPT and holds it in * the Vault as a token, we need to subtract the Vault's balance to get the total "circulating supply". Both the * totalSupply and Vault balance can change. If users join or exit using swaps, some of the preminted BPT are * exchanged, so the Vault's balance increases after joins and decreases after exits. If users call the recovery * mode exit function, the totalSupply can change as BPT are burned. * * The virtual supply can also be calculated by calling ComposablePoolLib.dropBptFromBalances with appropriate * inputs, which is the preferred approach whenever possible, as it avoids extra calls to the Vault. */ function _getVirtualSupply() internal view override returns (uint256) { (uint256 cash, uint256 managed, , ) = getVault().getPoolTokenInfo(getPoolId(), IERC20(this)); // We don't need to use SafeMath here as the Vault restricts token balances to be less than 2**112. // This ensures that `cash + managed` cannot overflow and the Pool's balance of BPT cannot exceed the total // supply so we cannot underflow either. return totalSupply() - (cash + managed); } // Swap Hooks /** * @dev Dispatch code for all kinds of swaps. Depending on the tokens involved this could result in a join, exit or * a standard swap between two token in the Pool. * * The return value is expected to be downscaled (appropriately rounded based on the swap type) ready to be passed * to the Vault. */ function _onSwapMinimal( SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut ) internal override returns (uint256) { bytes32 poolState = _getPoolState(); // ManagedPool is a composable Pool, so a swap could be either a join swap, an exit swap, or a token swap. // By checking whether the incoming or outgoing token is the BPT, we can determine which kind of // operation we want to perform and pass it to the appropriate handler. // // We block all types of swap if swaps are disabled as a token swap is equivalent to a join swap followed by // an exit swap into a different token. _require(ManagedPoolStorageLib.getSwapEnabled(poolState), Errors.SWAPS_DISABLED); if (request.tokenOut == IERC20(this)) { // `tokenOut` is the BPT, so this is a join swap. // Check allowlist for LPs, if applicable _require(_isAllowedAddress(poolState, request.from), Errors.ADDRESS_NOT_ALLOWLISTED); // This is equivalent to `_getVirtualSupply()`, but as `balanceTokenOut` is the Vault's balance of BPT // we can avoid querying this value again from the Vault as we do in `_getVirtualSupply()`. uint256 virtualSupply = totalSupply() - balanceTokenOut; // See documentation for `getActualSupply()` and `_collectAumManagementFees()`. uint256 actualSupply = virtualSupply + _collectAumManagementFees(virtualSupply); return _onJoinSwap(request, balanceTokenIn, actualSupply, poolState); } else if (request.tokenIn == IERC20(this)) { // `tokenIn` is the BPT, so this is an exit swap. // Note that we do not check the LP allowlist here. LPs must always be able to exit the pool, // and enforcing the allowlist would allow the manager to perform DOS attacks on LPs. // This is equivalent to `_getVirtualSupply()`, but as `balanceTokenIn` is the Vault's balance of BPT // we can avoid querying this value again from the Vault as we do in `_getVirtualSupply()`. uint256 virtualSupply = totalSupply() - balanceTokenIn; // See documentation for `getActualSupply()` and `_collectAumManagementFees()`. uint256 actualSupply = virtualSupply + _collectAumManagementFees(virtualSupply); return _onExitSwap(request, balanceTokenOut, actualSupply, poolState); } else { // Neither token is the BPT, so this is a standard token swap. return _onTokenSwap(request, balanceTokenIn, balanceTokenOut, poolState); } } /* * @dev Called when a swap with the Pool occurs, where the tokens leaving the Pool are BPT. * * This function is responsible for upscaling any amounts received, in particular `balanceTokenIn` * and `request.amount`. * * The return value is expected to be downscaled (appropriately rounded based on the swap type) ready to be passed * to the Vault. */ function _onJoinSwap( SwapRequest memory request, uint256 balanceTokenIn, uint256 actualSupply, bytes32 poolState ) internal view returns (uint256) { // Check whether joins are enabled. _require(ManagedPoolStorageLib.getJoinExitEnabled(poolState), Errors.JOINS_EXITS_DISABLED); // We first query data needed to perform the joinswap, i.e. the token weight and scaling factor as well as the // Pool's swap fee. (uint256 tokenInWeight, uint256 scalingFactorTokenIn) = _getTokenInfo( request.tokenIn, ManagedPoolStorageLib.getGradualWeightChangeProgress(poolState) ); uint256 swapFeePercentage = ManagedPoolStorageLib.getSwapFeePercentage(poolState); // `_onSwapMinimal` passes unscaled values so we upscale the token balance. balanceTokenIn = _upscale(balanceTokenIn, scalingFactorTokenIn); // We may also need to upscale `request.amount`, however we do not yet know this as that depends on whether that // is a token amount (GIVEN_IN) or a BPT amount (GIVEN_OUT), which gets no scaling. // // Therefore we branch depending on the swap kind and calculate the `bptAmountOut` for GIVEN_IN joinswaps or the // `amountIn` for GIVEN_OUT joinswaps. We call these values the `amountCalculated`. uint256 amountCalculated; if (request.kind == IVault.SwapKind.GIVEN_IN) { // In `GIVEN_IN` joinswaps, `request.amount` is the amount of tokens entering the pool so we upscale with // `scalingFactorTokenIn`. request.amount = _upscale(request.amount, scalingFactorTokenIn); // Once fees are removed we can then calculate the equivalent BPT amount. amountCalculated = _getWeightedMath().calcBptOutGivenExactTokenIn( balanceTokenIn, tokenInWeight, request.amount, actualSupply, swapFeePercentage ); } else { // In `GIVEN_OUT` joinswaps, `request.amount` is the amount of BPT leaving the pool, which does not need any // scaling. amountCalculated = _getWeightedMath().calcTokenInGivenExactBptOut( balanceTokenIn, tokenInWeight, request.amount, actualSupply, swapFeePercentage ); } // A joinswap decreases the price of the token entering the Pool and increases the price of all other tokens. // ManagedPool's circuit breakers prevent the tokens' prices from leaving certain bounds so we must check that // we haven't tripped a breaker as a result of the joinswap. _checkCircuitBreakersOnJoinOrExitSwap(request, actualSupply, amountCalculated, true); // Finally we downscale `amountCalculated` before we return it. if (request.kind == IVault.SwapKind.GIVEN_IN) { // BPT is leaving the Pool, which doesn't need scaling. return amountCalculated; } else { // `amountCalculated` tokens are entering the Pool, so we round up. return _downscaleUp(amountCalculated, scalingFactorTokenIn); } } /* * @dev Called when a swap with the Pool occurs, where the tokens entering the Pool are BPT. * * This function is responsible for upscaling any amounts received, in particular `balanceTokenOut` * and `request.amount`. * * The return value is expected to be downscaled (appropriately rounded based on the swap type) ready to be passed * to the Vault. */ function _onExitSwap( SwapRequest memory request, uint256 balanceTokenOut, uint256 actualSupply, bytes32 poolState ) internal view returns (uint256) { // Check whether exits are enabled. _require(ManagedPoolStorageLib.getJoinExitEnabled(poolState), Errors.JOINS_EXITS_DISABLED); // We first query data needed to perform the exitswap, i.e. the token weight and scaling factor as well as the // Pool's swap fee. (uint256 tokenOutWeight, uint256 scalingFactorTokenOut) = _getTokenInfo( request.tokenOut, ManagedPoolStorageLib.getGradualWeightChangeProgress(poolState) ); uint256 swapFeePercentage = ManagedPoolStorageLib.getSwapFeePercentage(poolState); // `_onSwapMinimal` passes unscaled values so we upscale the token balance. balanceTokenOut = _upscale(balanceTokenOut, scalingFactorTokenOut); // We may also need to upscale `request.amount`, however we do not yet know this as that depends on whether that // is a BPT amount (GIVEN_IN), which gets no scaling, or a token amount (GIVEN_OUT). // // Therefore we branch depending on the swap kind and calculate the `amountOut` for GIVEN_IN exitswaps or the // `bptAmountIn` for GIVEN_OUT exitswaps. We call these values the `amountCalculated`. uint256 amountCalculated; if (request.kind == IVault.SwapKind.GIVEN_IN) { // In `GIVEN_IN` exitswaps, `request.amount` is the amount of BPT entering the pool, which does not need any // scaling. amountCalculated = _getWeightedMath().calcTokenOutGivenExactBptIn( balanceTokenOut, tokenOutWeight, request.amount, actualSupply, swapFeePercentage ); } else { // In `GIVEN_OUT` exitswaps, `request.amount` is the amount of tokens leaving the pool so we upscale with // `scalingFactorTokenOut`. request.amount = _upscale(request.amount, scalingFactorTokenOut); amountCalculated = _getWeightedMath().calcBptInGivenExactTokenOut( balanceTokenOut, tokenOutWeight, request.amount, actualSupply, swapFeePercentage ); } // A exitswap increases the price of the token leaving the Pool and decreases the price of all other tokens. // ManagedPool's circuit breakers prevent the tokens' prices from leaving certain bounds so we must check that // we haven't tripped a breaker as a result of the exitswap. _checkCircuitBreakersOnJoinOrExitSwap(request, actualSupply, amountCalculated, false); // Finally we downscale `amountCalculated` before we return it. if (request.kind == IVault.SwapKind.GIVEN_IN) { // `amountCalculated` tokens are exiting the Pool, so we round down. return _downscaleDown(amountCalculated, scalingFactorTokenOut); } else { // BPT is entering the Pool, which doesn't need scaling. return amountCalculated; } } // Holds information for the tokens involved in a regular swap. struct SwapTokenData { uint256 tokenInWeight; uint256 tokenOutWeight; uint256 scalingFactorTokenIn; uint256 scalingFactorTokenOut; } /* * @dev Called when a swap with the Pool occurs, where neither of the tokens involved are the BPT of the Pool. * * This function is responsible for upscaling any amounts received, in particular `balanceTokenIn`, * `balanceTokenOut` and `request.amount`. * * The return value is expected to be downscaled (appropriately rounded based on the swap type) ready to be passed * to the Vault. */ function _onTokenSwap( SwapRequest memory request, uint256 balanceTokenIn, uint256 balanceTokenOut, bytes32 poolState ) internal view returns (uint256) { // We first query data needed to perform the swap, i.e. token weights and scaling factors as well as the Pool's // swap fee (in the form of its complement). SwapTokenData memory tokenData = _getSwapTokenData(request, poolState); uint256 swapFeeComplement = ManagedPoolStorageLib.getSwapFeePercentage(poolState).complement(); // `_onSwapMinimal` passes unscaled values so we upscale token balances using the appropriate scaling factors. balanceTokenIn = _upscale(balanceTokenIn, tokenData.scalingFactorTokenIn); balanceTokenOut = _upscale(balanceTokenOut, tokenData.scalingFactorTokenOut); // We must also upscale `request.amount` however we do not yet know which scaling factor to use as this differs // depending on whether it represents an amount of tokens entering (GIVEN_IN) or leaving (GIVEN_OUT) the Pool. // // Therefore we branch depending on the swap kind and calculate the `amountOut` for GIVEN_IN swaps or the // `amountIn` for GIVEN_OUT swaps. We call these values the `amountCalculated`. uint256 amountCalculated; if (request.kind == IVault.SwapKind.GIVEN_IN) { // In `GIVEN_IN` swaps, `request.amount` is the amount of tokens entering the pool so we upscale with // `scalingFactorTokenIn`. request.amount = _upscale(request.amount, tokenData.scalingFactorTokenIn); // We then subtract swap fees from this amount so the collected swap fees aren't use to calculate how many // tokens the trader will receive. We round this value down (favoring a higher fee amount). uint256 amountInMinusFees = request.amount.mulDown(swapFeeComplement); // Once fees are removed we can then calculate the equivalent amount of `tokenOut`. amountCalculated = _getWeightedMath().calcOutGivenIn( balanceTokenIn, tokenData.tokenInWeight, balanceTokenOut, tokenData.tokenOutWeight, amountInMinusFees ); } else { // In `GIVEN_OUT` swaps, `request.amount` is the amount of tokens leaving the pool so we upscale with // `scalingFactorTokenOut`. request.amount = _upscale(request.amount, tokenData.scalingFactorTokenOut); // We first calculate how many tokens must be sent in order to receive `request.amount` tokens out. // This calculation does not yet include fees. uint256 amountInMinusFees = _getWeightedMath().calcInGivenOut( balanceTokenIn, tokenData.tokenInWeight, balanceTokenOut, tokenData.tokenOutWeight, request.amount ); // We then add swap fees to this amount so the trader must send extra tokens. // We round this value up (favoring a higher fee amount). amountCalculated = amountInMinusFees.divUp(swapFeeComplement); } // A token swap increases the price of the token leaving the Pool and reduces the price of the token entering // the Pool. ManagedPool's circuit breakers prevent the tokens' prices from leaving certain bounds so we must // check that we haven't tripped a breaker as a result of the token swap. _checkCircuitBreakersOnRegularSwap(request, tokenData, balanceTokenIn, balanceTokenOut, amountCalculated); // Finally we downscale `amountCalculated` before we return it. We want to round this value in favour of the // Pool so apply different scaling on amounts entering or leaving the Pool. if (request.kind == IVault.SwapKind.GIVEN_IN) { // `amountCalculated` tokens are exiting the Pool, so we round down. return _downscaleDown(amountCalculated, tokenData.scalingFactorTokenOut); } else { // `amountCalculated` tokens are entering the Pool, so we round up. return _downscaleUp(amountCalculated, tokenData.scalingFactorTokenIn); } } /** * @dev Gather the information required to process a regular token swap. This is required to avoid stack-too-deep * issues. */ function _getSwapTokenData(SwapRequest memory request, bytes32 poolState) private view returns (SwapTokenData memory tokenInfo) { bytes32 tokenInState = _getTokenState(request.tokenIn); bytes32 tokenOutState = _getTokenState(request.tokenOut); uint256 weightChangeProgress = ManagedPoolStorageLib.getGradualWeightChangeProgress(poolState); tokenInfo.tokenInWeight = ManagedPoolTokenStorageLib.getTokenWeight(tokenInState, weightChangeProgress); tokenInfo.tokenOutWeight = ManagedPoolTokenStorageLib.getTokenWeight(tokenOutState, weightChangeProgress); tokenInfo.scalingFactorTokenIn = ManagedPoolTokenStorageLib.getTokenScalingFactor(tokenInState); tokenInfo.scalingFactorTokenOut = ManagedPoolTokenStorageLib.getTokenScalingFactor(tokenOutState); } /** * @notice Returns a token's weight and scaling factor */ function _getTokenInfo(IERC20 token, uint256 weightChangeProgress) private view returns (uint256 tokenWeight, uint256 scalingFactor) { bytes32 tokenState = _getTokenState(token); tokenWeight = ManagedPoolTokenStorageLib.getTokenWeight(tokenState, weightChangeProgress); scalingFactor = ManagedPoolTokenStorageLib.getTokenScalingFactor(tokenState); } // Initialize function _onInitializePool( address sender, address, bytes memory userData ) internal override returns (uint256 bptAmountOut, uint256[] memory amountsIn) { // Check allowlist for LPs, if applicable _require(_isAllowedAddress(_getPoolState(), sender), Errors.ADDRESS_NOT_ALLOWLISTED); // Ensure that the user intends to initialize the Pool. WeightedPoolUserData.JoinKind kind = userData.joinKind(); _require(kind == WeightedPoolUserData.JoinKind.INIT, Errors.UNINITIALIZED); // Extract the initial token balances `sender` is sending to the Pool. (IERC20[] memory tokens, ) = _getPoolTokens(); amountsIn = userData.initialAmountsIn(); InputHelpers.ensureInputLengthMatch(amountsIn.length, tokens.length); // We now want to determine the correct amount of BPT to mint in return for these tokens. // In order to do this we calculate the Pool's invariant which requires the token amounts to be upscaled. uint256[] memory scalingFactors = _scalingFactors(tokens); _upscaleArray(amountsIn, scalingFactors); uint256 invariantAfterJoin = _getWeightedMath().calculateInvariant(_getNormalizedWeights(tokens), amountsIn); // Set the initial BPT to the value of the invariant times the number of tokens. This makes BPT supply more // consistent in Pools with similar compositions but different number of tokens. bptAmountOut = Math.mul(invariantAfterJoin, amountsIn.length); // We don't need upscaled balances anymore and will need to return downscaled amounts so we downscale here. // `amountsIn` are amounts entering the Pool, so we round up when doing this. _downscaleUpArray(amountsIn, scalingFactors); // BasePool will mint `bptAmountOut` for the sender: we then also mint the remaining BPT to make up the total // supply, and have the Vault pull those tokens from the sender as part of the join. // // Note that the sender need not approve BPT for the Vault as the Vault already has infinite BPT allowance for // all accounts. uint256 initialBpt = _PREMINTED_TOKEN_BALANCE.sub(bptAmountOut); _mintPoolTokens(sender, initialBpt); // The Vault expects an array of amounts which includes BPT (which always sits in the first position). // We then add an extra element to the beginning of the array and set it to `initialBpt`. amountsIn = ComposablePoolLib.prependZeroElement(amountsIn); amountsIn[0] = initialBpt; // At this point we have all necessary return values for the initialization. // Finally, we want to start collecting AUM fees from this point onwards. Prior to initialization the Pool holds // no funds so naturally charges no AUM fees. _updateAumFeeCollectionTimestamp(); } // Join function _onJoinPool( address sender, uint256[] memory balances, bytes memory userData ) internal virtual override returns (uint256 bptAmountOut, uint256[] memory amountsIn) { // The Vault passes an array of balances which includes the pool's BPT (This always sits in the first position). // We want to separate this from the other balances before continuing with the join. uint256 virtualSupply; (virtualSupply, balances) = ComposablePoolLib.dropBptFromBalances(totalSupply(), balances); // We want to upscale all of the balances received from the Vault by the appropriate scaling factors. // In order to do this we must query the Pool's tokens from the Vault as ManagedPool doesn't keep track. (IERC20[] memory tokens, ) = _getPoolTokens(); uint256[] memory scalingFactors = _scalingFactors(tokens); _upscaleArray(balances, scalingFactors); // See documentation for `getActualSupply()` and `_collectAumManagementFees()`. uint256 actualSupply = virtualSupply + _collectAumManagementFees(virtualSupply); uint256[] memory normalizedWeights = _getNormalizedWeights(tokens); (bptAmountOut, amountsIn) = _doJoin( sender, balances, normalizedWeights, scalingFactors, actualSupply, userData ); _checkCircuitBreakers(actualSupply.add(bptAmountOut), tokens, balances, amountsIn, normalizedWeights, true); // amountsIn are amounts entering the Pool, so we round up. _downscaleUpArray(amountsIn, scalingFactors); // The Vault expects an array of amounts which includes BPT so prepend an empty element to this array. amountsIn = ComposablePoolLib.prependZeroElement(amountsIn); } /** * @dev Dispatch code which decodes the provided userdata to perform the specified join type. */ function _doJoin( address sender, uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, bytes memory userData ) internal view returns (uint256, uint256[] memory) { bytes32 poolState = _getPoolState(); // Check whether joins are enabled. _require(ManagedPoolStorageLib.getJoinExitEnabled(poolState), Errors.JOINS_EXITS_DISABLED); WeightedPoolUserData.JoinKind kind = userData.joinKind(); // If swaps are disabled, only proportional joins are allowed. All others involve implicit swaps, and alter // token prices. _require( ManagedPoolStorageLib.getSwapEnabled(poolState) || kind == WeightedPoolUserData.JoinKind.ALL_TOKENS_IN_FOR_EXACT_BPT_OUT, Errors.INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED ); // Check allowlist for LPs, if applicable _require(_isAllowedAddress(poolState, sender), Errors.ADDRESS_NOT_ALLOWLISTED); if (kind == WeightedPoolUserData.JoinKind.EXACT_TOKENS_IN_FOR_BPT_OUT) { return _getWeightedMath().joinExactTokensInForBPTOut( balances, normalizedWeights, scalingFactors, totalSupply, ManagedPoolStorageLib.getSwapFeePercentage(poolState), userData ); } else if (kind == WeightedPoolUserData.JoinKind.TOKEN_IN_FOR_EXACT_BPT_OUT) { return _getWeightedMath().joinTokenInForExactBPTOut( balances, normalizedWeights, totalSupply, ManagedPoolStorageLib.getSwapFeePercentage(poolState), userData ); } else if (kind == WeightedPoolUserData.JoinKind.ALL_TOKENS_IN_FOR_EXACT_BPT_OUT) { return _getWeightedMath().joinAllTokensInForExactBPTOut(balances, totalSupply, userData); } else { _revert(Errors.UNHANDLED_JOIN_KIND); } } // Exit function _onExitPool( address sender, uint256[] memory balances, bytes memory userData ) internal virtual override returns (uint256 bptAmountIn, uint256[] memory amountsOut) { // The Vault passes an array of balances which includes the pool's BPT (This always sits in the first position). // We want to separate this from the other balances before continuing with the exit. uint256 virtualSupply; (virtualSupply, balances) = ComposablePoolLib.dropBptFromBalances(totalSupply(), balances); // We want to upscale all of the balances received from the Vault by the appropriate scaling factors. // In order to do this we must query the Pool's tokens from the Vault as ManagedPool doesn't keep track. (IERC20[] memory tokens, ) = _getPoolTokens(); uint256[] memory scalingFactors = _scalingFactors(tokens); _upscaleArray(balances, scalingFactors); // See documentation for `getActualSupply()` and `_collectAumManagementFees()`. uint256 actualSupply = virtualSupply + _collectAumManagementFees(virtualSupply); uint256[] memory normalizedWeights = _getNormalizedWeights(tokens); (bptAmountIn, amountsOut) = _doExit( sender, balances, normalizedWeights, scalingFactors, actualSupply, userData ); // Do not check circuit breakers on proportional exits, which do not change BPT prices. if (userData.exitKind() != WeightedPoolUserData.ExitKind.EXACT_BPT_IN_FOR_TOKENS_OUT) { _checkCircuitBreakers( actualSupply.sub(bptAmountIn), tokens, balances, amountsOut, normalizedWeights, false ); } // amountsOut are amounts exiting the Pool, so we round down. _downscaleDownArray(amountsOut, scalingFactors); // The Vault expects an array of amounts which includes BPT so prepend an empty element to this array. amountsOut = ComposablePoolLib.prependZeroElement(amountsOut); } /** * @dev Dispatch code which decodes the provided userdata to perform the specified exit type. * Inheriting contracts may override this function to add additional exit types or extra conditions to allow * or disallow exit under certain circumstances. */ function _doExit( address, uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, bytes memory userData ) internal view virtual returns (uint256, uint256[] memory) { bytes32 poolState = _getPoolState(); // Check whether exits are enabled. Recovery mode exits are not blocked by this check, since they are routed // through a different codepath at the base pool layer. _require(ManagedPoolStorageLib.getJoinExitEnabled(poolState), Errors.JOINS_EXITS_DISABLED); WeightedPoolUserData.ExitKind kind = userData.exitKind(); // If swaps are disabled, only proportional exits are allowed. All others involve implicit swaps, and alter // token prices. _require( ManagedPoolStorageLib.getSwapEnabled(poolState) || kind == WeightedPoolUserData.ExitKind.EXACT_BPT_IN_FOR_TOKENS_OUT, Errors.INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED ); // Note that we do not check the LP allowlist here. LPs must always be able to exit the pool, // and enforcing the allowlist would allow the manager to perform DOS attacks on LPs. if (kind == WeightedPoolUserData.ExitKind.EXACT_BPT_IN_FOR_ONE_TOKEN_OUT) { return _getWeightedMath().exitExactBPTInForTokenOut( balances, normalizedWeights, totalSupply, ManagedPoolStorageLib.getSwapFeePercentage(poolState), userData ); } else if (kind == WeightedPoolUserData.ExitKind.EXACT_BPT_IN_FOR_TOKENS_OUT) { return _getWeightedMath().exitExactBPTInForTokensOut(balances, totalSupply, userData); } else if (kind == WeightedPoolUserData.ExitKind.BPT_IN_FOR_EXACT_TOKENS_OUT) { return _getWeightedMath().exitBPTInForExactTokensOut( balances, normalizedWeights, scalingFactors, totalSupply, ManagedPoolStorageLib.getSwapFeePercentage(poolState), userData ); } else { _revert(Errors.UNHANDLED_EXIT_KIND); } } function _doRecoveryModeExit( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) internal pure override returns (uint256 bptAmountIn, uint256[] memory amountsOut) { // As ManagedPool is a composable Pool, `_doRecoveryModeExit()` must use the virtual supply rather than the // total supply to correctly distribute Pool assets proportionally. // We must also ensure that we do not pay out a proportionaly fraction of the BPT held in the Vault, otherwise // this would allow a user to recursively exit the pool using BPT they received from the previous exit. uint256 virtualSupply; (virtualSupply, balances) = ComposablePoolLib.dropBptFromBalances(totalSupply, balances); bptAmountIn = userData.recoveryModeExit(); amountsOut = BasePoolMath.computeProportionalAmountsOut(balances, virtualSupply, bptAmountIn); // The Vault expects an array of amounts which includes BPT so prepend an empty element to this array. amountsOut = ComposablePoolLib.prependZeroElement(amountsOut); } /** * @notice Returns the tokens in the Pool and their current balances. * @dev This function drops the BPT token and its balance from the returned arrays as these values are unused by * internal functions outside of the swap/join/exit hooks. */ function _getPoolTokens() internal view override returns (IERC20[] memory, uint256[] memory) { (IERC20[] memory registeredTokens, uint256[] memory registeredBalances, ) = getVault().getPoolTokens( getPoolId() ); return ComposablePoolLib.dropBpt(registeredTokens, registeredBalances); } // Circuit Breakers // Depending on the type of operation, we may need to check only the upper or lower bound, or both. enum BoundCheckKind { LOWER, UPPER, BOTH } /** * @dev Check the circuit breakers of the two tokens involved in a regular swap. */ function _checkCircuitBreakersOnRegularSwap( SwapRequest memory request, SwapTokenData memory tokenData, uint256 balanceTokenIn, uint256 balanceTokenOut, uint256 amountCalculated ) private view { uint256 actualSupply = _getActualSupply(_getVirtualSupply()); (uint256 amountIn, uint256 amountOut) = request.kind == IVault.SwapKind.GIVEN_IN ? (request.amount, amountCalculated) : (amountCalculated, request.amount); // Since the balance of tokenIn is increasing, its BPT price will decrease, // so we need to check the lower bound. _checkCircuitBreaker( BoundCheckKind.LOWER, request.tokenIn, actualSupply, balanceTokenIn.add(amountIn), tokenData.tokenInWeight ); // Since the balance of tokenOut is decreasing, its BPT price will increase, // so we need to check the upper bound. _checkCircuitBreaker( BoundCheckKind.UPPER, request.tokenOut, actualSupply, balanceTokenOut.sub(amountOut), tokenData.tokenOutWeight ); } /** * @dev We need to check the breakers for all tokens on joins and exits (including join and exit swaps), since any * change to the BPT supply affects all BPT prices. For a multi-token join or exit, we will have a set of * balances and amounts. For a join/exitSwap, only one token balance is changing. We can use the same data for * both: in the single token swap case, the other token `amounts` will be zero. */ function _checkCircuitBreakersOnJoinOrExitSwap( SwapRequest memory request, uint256 actualSupply, uint256 amountCalculated, bool isJoin ) private view { uint256 newActualSupply; uint256 amount; // This is a swap between the BPT token and another pool token. Calculate the end state: actualSupply // and the token amount being swapped, depending on whether it is a join or exit, GivenIn or GivenOut. if (isJoin) { (newActualSupply, amount) = request.kind == IVault.SwapKind.GIVEN_IN ? (actualSupply.add(amountCalculated), request.amount) : (actualSupply.add(request.amount), amountCalculated); } else { (newActualSupply, amount) = request.kind == IVault.SwapKind.GIVEN_IN ? (actualSupply.sub(request.amount), amountCalculated) : (actualSupply.sub(amountCalculated), request.amount); } // Since this is a swap, we do not have all the tokens, balances, or weights, and need to fetch them. (IERC20[] memory tokens, uint256[] memory balances) = _getPoolTokens(); uint256[] memory normalizedWeights = _getNormalizedWeights(tokens); _upscaleArray(balances, _scalingFactors(tokens)); // Initialize to all zeros, and set the amount associated with the swap. uint256[] memory amounts = new uint256[](tokens.length); IERC20 token = isJoin ? request.tokenIn : request.tokenOut; for (uint256 i = 0; i < tokens.length; i++) { if (tokens[i] == token) { amounts[i] = amount; break; } } _checkCircuitBreakers(newActualSupply, tokens, balances, amounts, normalizedWeights, isJoin); } /** * @dev Check circuit breakers for a set of tokens. The given virtual supply is what it will be post-operation: * this includes any pending external fees, and the amount of BPT exchanged (swapped, minted, or burned) in the * current operation. * * We pass in the tokens, upscaled balances, and weights necessary to compute BPT prices, then check the circuit * breakers. Unlike a straightforward token swap, where we know the direction the BPT price will move, once the * virtual supply changes, all bets are off. To be safe, we need to check both directions for all tokens. * * It does attempt to short circuit quickly if there is no bound set. */ function _checkCircuitBreakers( uint256 actualSupply, IERC20[] memory tokens, uint256[] memory balances, uint256[] memory amounts, uint256[] memory normalizedWeights, bool isJoin ) private view { for (uint256 i = 0; i < balances.length; i++) { uint256 finalBalance = (isJoin ? FixedPoint.add : FixedPoint.sub)(balances[i], amounts[i]); // Since we cannot be sure which direction the BPT price of the token has moved, // we must check both the lower and upper bounds. _checkCircuitBreaker(BoundCheckKind.BOTH, tokens[i], actualSupply, finalBalance, normalizedWeights[i]); } } // Check the appropriate circuit breaker(s) according to the BoundCheckKind. function _checkCircuitBreaker( BoundCheckKind checkKind, IERC20 token, uint256 actualSupply, uint256 balance, uint256 weight ) private view { bytes32 circuitBreakerState = _getCircuitBreakerState(token); if (checkKind == BoundCheckKind.LOWER || checkKind == BoundCheckKind.BOTH) { _checkOneSidedCircuitBreaker(circuitBreakerState, actualSupply, balance, weight, true); } if (checkKind == BoundCheckKind.UPPER || checkKind == BoundCheckKind.BOTH) { _checkOneSidedCircuitBreaker(circuitBreakerState, actualSupply, balance, weight, false); } } // Check either the lower or upper bound circuit breaker for the given token. function _checkOneSidedCircuitBreaker( bytes32 circuitBreakerState, uint256 actualSupply, uint256 balance, uint256 weight, bool isLowerBound ) private pure { uint256 bound = CircuitBreakerStorageLib.getBptPriceBound(circuitBreakerState, weight, isLowerBound); _require( !CircuitBreakerLib.hasCircuitBreakerTripped(actualSupply, weight, balance, bound, isLowerBound), Errors.CIRCUIT_BREAKER_TRIPPED ); } // Unimplemented /** * @dev Unimplemented as ManagedPool uses the MinimalInfoSwap Pool specialization. */ function _onSwapGeneral( SwapRequest memory, /*request*/ uint256[] memory, /* balances*/ uint256, /* indexIn */ uint256 /*indexOut */ ) internal pure override returns (uint256) { _revert(Errors.UNIMPLEMENTED); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library WeightedExitsLib { using WeightedPoolUserData for bytes; function exitExactBPTInForTokenOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) internal pure returns (uint256, uint256[] memory) { (uint256 bptAmountIn, uint256 tokenIndex) = userData.exactBptInForTokenOut(); // Note that there is no minimum amountOut parameter: this is handled by `IVault.exitPool`. _require(tokenIndex < balances.length, Errors.OUT_OF_BOUNDS); uint256 amountOut = WeightedMath._calcTokenOutGivenExactBptIn( balances[tokenIndex], normalizedWeights[tokenIndex], bptAmountIn, totalSupply, swapFeePercentage ); // This is an exceptional situation in which the fee is charged on a token out instead of a token in. // We exit in a single token, so we initialize amountsOut with zeros uint256[] memory amountsOut = new uint256[](balances.length); // And then assign the result to the selected token amountsOut[tokenIndex] = amountOut; return (bptAmountIn, amountsOut); } function exitExactBPTInForTokensOut( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) internal pure returns (uint256 bptAmountIn, uint256[] memory amountsOut) { bptAmountIn = userData.exactBptInForTokensOut(); // Note that there is no minimum amountOut parameter: this is handled by `IVault.exitPool`. amountsOut = BasePoolMath.computeProportionalAmountsOut(balances, totalSupply, bptAmountIn); } function exitBPTInForExactTokensOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) internal pure returns (uint256, uint256[] memory) { (uint256[] memory amountsOut, uint256 maxBPTAmountIn) = userData.bptInForExactTokensOut(); InputHelpers.ensureInputLengthMatch(amountsOut.length, balances.length); _upscaleArray(amountsOut, scalingFactors); // This is an exceptional situation in which the fee is charged on a token out instead of a token in. uint256 bptAmountIn = WeightedMath._calcBptInGivenExactTokensOut( balances, normalizedWeights, amountsOut, totalSupply, swapFeePercentage ); _require(bptAmountIn <= maxBPTAmountIn, Errors.BPT_IN_MAX_AMOUNT); return (bptAmountIn, amountsOut); } } // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. library WeightedJoinsLib { using WeightedPoolUserData for bytes; function joinExactTokensInForBPTOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) internal pure returns (uint256, uint256[] memory) { (uint256[] memory amountsIn, uint256 minBPTAmountOut) = userData.exactTokensInForBptOut(); InputHelpers.ensureInputLengthMatch(balances.length, amountsIn.length); _upscaleArray(amountsIn, scalingFactors); uint256 bptAmountOut = WeightedMath._calcBptOutGivenExactTokensIn( balances, normalizedWeights, amountsIn, totalSupply, swapFeePercentage ); _require(bptAmountOut >= minBPTAmountOut, Errors.BPT_OUT_MIN_AMOUNT); return (bptAmountOut, amountsIn); } function joinTokenInForExactBPTOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) internal pure returns (uint256, uint256[] memory) { (uint256 bptAmountOut, uint256 tokenIndex) = userData.tokenInForExactBptOut(); // Note that there is no maximum amountIn parameter: this is handled by `IVault.joinPool`. _require(tokenIndex < balances.length, Errors.OUT_OF_BOUNDS); uint256 amountIn = WeightedMath._calcTokenInGivenExactBptOut( balances[tokenIndex], normalizedWeights[tokenIndex], bptAmountOut, totalSupply, swapFeePercentage ); // We join in a single token, so we initialize amountsIn with zeros uint256[] memory amountsIn = new uint256[](balances.length); // And then assign the result to the selected token amountsIn[tokenIndex] = amountIn; return (bptAmountOut, amountsIn); } function joinAllTokensInForExactBPTOut( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) internal pure returns (uint256 bptAmountOut, uint256[] memory amountsIn) { bptAmountOut = userData.allTokensInForExactBptOut(); // Note that there is no maximum amountsIn parameter: this is handled by `IVault.joinPool`. amountsIn = BasePoolMath.computeProportionalAmountsIn(balances, totalSupply, bptAmountOut); } } /** * @notice A contract-wrapper for Weighted Math, Joins and Exits. * @dev Use this contract as an external replacement for WeightedMath, WeightedJoinsLib and WeightedExitsLib libraries. */ contract ExternalWeightedMath is IExternalWeightedMath { function calculateInvariant(uint256[] memory normalizedWeights, uint256[] memory balances) external pure override returns (uint256) { return WeightedMath._calculateInvariant(normalizedWeights, balances); } function calcOutGivenIn( uint256 balanceIn, uint256 weightIn, uint256 balanceOut, uint256 weightOut, uint256 amountIn ) external pure override returns (uint256) { return WeightedMath._calcOutGivenIn(balanceIn, weightIn, balanceOut, weightOut, amountIn); } function calcInGivenOut( uint256 balanceIn, uint256 weightIn, uint256 balanceOut, uint256 weightOut, uint256 amountOut ) external pure override returns (uint256) { return WeightedMath._calcInGivenOut(balanceIn, weightIn, balanceOut, weightOut, amountOut); } function calcBptOutGivenExactTokensIn( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure override returns (uint256) { return WeightedMath._calcBptOutGivenExactTokensIn( balances, normalizedWeights, amountsIn, bptTotalSupply, swapFeePercentage ); } function calcBptOutGivenExactTokenIn( uint256 balance, uint256 normalizedWeight, uint256 amountIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure override returns (uint256) { return WeightedMath._calcBptOutGivenExactTokenIn( balance, normalizedWeight, amountIn, bptTotalSupply, swapFeePercentage ); } function calcTokenInGivenExactBptOut( uint256 balance, uint256 normalizedWeight, uint256 bptAmountOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure override returns (uint256) { return WeightedMath._calcTokenInGivenExactBptOut( balance, normalizedWeight, bptAmountOut, bptTotalSupply, swapFeePercentage ); } function calcAllTokensInGivenExactBptOut( uint256[] memory balances, uint256 bptAmountOut, uint256 totalBPT ) external pure override returns (uint256[] memory) { return BasePoolMath.computeProportionalAmountsIn(balances, totalBPT, bptAmountOut); } function calcBptInGivenExactTokensOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory amountsOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure override returns (uint256) { return WeightedMath._calcBptInGivenExactTokensOut( balances, normalizedWeights, amountsOut, bptTotalSupply, swapFeePercentage ); } function calcBptInGivenExactTokenOut( uint256 balance, uint256 normalizedWeight, uint256 amountOut, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure override returns (uint256) { return WeightedMath._calcBptInGivenExactTokenOut( balance, normalizedWeight, amountOut, bptTotalSupply, swapFeePercentage ); } function calcTokenOutGivenExactBptIn( uint256 balance, uint256 normalizedWeight, uint256 bptAmountIn, uint256 bptTotalSupply, uint256 swapFeePercentage ) external pure override returns (uint256) { return WeightedMath._calcTokenOutGivenExactBptIn( balance, normalizedWeight, bptAmountIn, bptTotalSupply, swapFeePercentage ); } function calcTokensOutGivenExactBptIn( uint256[] memory balances, uint256 bptAmountIn, uint256 totalBPT ) external pure override returns (uint256[] memory) { return BasePoolMath.computeProportionalAmountsOut(balances, totalBPT, bptAmountIn); } function calcBptOutAddToken(uint256 totalSupply, uint256 normalizedWeight) external pure override returns (uint256) { return WeightedMath._calcBptOutAddToken(totalSupply, normalizedWeight); } function joinExactTokensInForBPTOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure override returns (uint256, uint256[] memory) { return WeightedJoinsLib.joinExactTokensInForBPTOut( balances, normalizedWeights, scalingFactors, totalSupply, swapFeePercentage, userData ); } function joinTokenInForExactBPTOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure override returns (uint256, uint256[] memory) { return WeightedJoinsLib.joinTokenInForExactBPTOut( balances, normalizedWeights, totalSupply, swapFeePercentage, userData ); } function joinAllTokensInForExactBPTOut( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) external pure override returns (uint256 bptAmountOut, uint256[] memory amountsIn) { return WeightedJoinsLib.joinAllTokensInForExactBPTOut(balances, totalSupply, userData); } function exitExactBPTInForTokenOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure override returns (uint256, uint256[] memory) { return WeightedExitsLib.exitExactBPTInForTokenOut( balances, normalizedWeights, totalSupply, swapFeePercentage, userData ); } function exitExactBPTInForTokensOut( uint256[] memory balances, uint256 totalSupply, bytes memory userData ) external pure override returns (uint256 bptAmountIn, uint256[] memory amountsOut) { return WeightedExitsLib.exitExactBPTInForTokensOut(balances, totalSupply, userData); } function exitBPTInForExactTokensOut( uint256[] memory balances, uint256[] memory normalizedWeights, uint256[] memory scalingFactors, uint256 totalSupply, uint256 swapFeePercentage, bytes memory userData ) external pure override returns (uint256, uint256[] memory) { return WeightedExitsLib.exitBPTInForExactTokensOut( balances, normalizedWeights, scalingFactors, totalSupply, swapFeePercentage, userData ); } } /** * @dev This is a base factory designed to be called from other factories to deploy a ManagedPool * with a particular contract as the owner. This contract might have a privileged or admin account * to perform permissioned actions: this account is often called the pool manager. * * This factory should NOT be used directly to deploy ManagedPools owned by EOAs. ManagedPools * owned by EOAs would be very dangerous for LPs. There are no restrictions on what the owner * can do, so a malicious owner could easily manipulate prices and drain the pool. * * In this design, other client-specific factories will deploy a contract, then call this factory * to deploy the pool, passing in that contract address as the owner. */ contract ManagedPoolFactory is IFactoryCreatedPoolVersion, Version, BasePoolFactory { IExternalWeightedMath private immutable _weightedMath; string private _poolVersion; constructor( IVault vault, IProtocolFeePercentagesProvider protocolFeeProvider, string memory factoryVersion, string memory poolVersion, uint256 initialPauseWindowDuration, uint256 bufferPeriodDuration ) BasePoolFactory( vault, protocolFeeProvider, initialPauseWindowDuration, bufferPeriodDuration, type(ManagedPool).creationCode ) Version(factoryVersion) { _weightedMath = new ExternalWeightedMath(); _poolVersion = poolVersion; } function getPoolVersion() public view override returns (string memory) { return _poolVersion; } function getWeightedMath() external view returns (IExternalWeightedMath) { return _weightedMath; } /** * @dev Deploys a new `ManagedPool`. The owner should be a contract, deployed by another factory. */ function create( ManagedPool.ManagedPoolParams memory params, ManagedPoolSettings.ManagedPoolSettingsParams memory settingsParams, address owner ) external returns (address pool) { (uint256 pauseWindowDuration, uint256 bufferPeriodDuration) = getPauseConfiguration(); ManagedPool.ManagedPoolConfigParams memory configParams = ManagedPool.ManagedPoolConfigParams({ vault: getVault(), protocolFeeProvider: getProtocolFeePercentagesProvider(), weightedMath: _weightedMath, pauseWindowDuration: pauseWindowDuration, bufferPeriodDuration: bufferPeriodDuration, version: getPoolVersion() }); return _create(abi.encode(params, configParams, settingsParams, owner)); } }
Contract ABI
[{"type":"constructor","stateMutability":"nonpayable","inputs":[{"type":"address","name":"vault","internalType":"contract IVault"},{"type":"address","name":"protocolFeeProvider","internalType":"contract IProtocolFeePercentagesProvider"},{"type":"string","name":"factoryVersion","internalType":"string"},{"type":"string","name":"poolVersion","internalType":"string"},{"type":"uint256","name":"initialPauseWindowDuration","internalType":"uint256"},{"type":"uint256","name":"bufferPeriodDuration","internalType":"uint256"}]},{"type":"event","name":"FactoryDisabled","inputs":[],"anonymous":false},{"type":"event","name":"PoolCreated","inputs":[{"type":"address","name":"pool","internalType":"address","indexed":true}],"anonymous":false},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"address","name":"pool","internalType":"address"}],"name":"create","inputs":[{"type":"tuple","name":"params","internalType":"struct ManagedPool.ManagedPoolParams","components":[{"type":"string","name":"name","internalType":"string"},{"type":"string","name":"symbol","internalType":"string"},{"type":"address[]","name":"assetManagers","internalType":"address[]"}]},{"type":"tuple","name":"settingsParams","internalType":"struct ManagedPoolSettings.ManagedPoolSettingsParams","components":[{"type":"address[]","name":"tokens","internalType":"contract IERC20[]"},{"type":"uint256[]","name":"normalizedWeights","internalType":"uint256[]"},{"type":"uint256","name":"swapFeePercentage","internalType":"uint256"},{"type":"bool","name":"swapEnabledOnStart","internalType":"bool"},{"type":"bool","name":"mustAllowlistLPs","internalType":"bool"},{"type":"uint256","name":"managementAumFeePercentage","internalType":"uint256"},{"type":"uint256","name":"aumFeeId","internalType":"uint256"}]},{"type":"address","name":"owner","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"disable","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"getActionId","inputs":[{"type":"bytes4","name":"selector","internalType":"bytes4"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IAuthorizer"}],"name":"getAuthorizer","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes","name":"","internalType":"bytes"}],"name":"getCreationCode","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"contractA","internalType":"address"},{"type":"address","name":"contractB","internalType":"address"}],"name":"getCreationCodeContracts","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"pauseWindowDuration","internalType":"uint256"},{"type":"uint256","name":"bufferPeriodDuration","internalType":"uint256"}],"name":"getPauseConfiguration","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"getPoolVersion","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IProtocolFeePercentagesProvider"}],"name":"getProtocolFeePercentagesProvider","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IVault"}],"name":"getVault","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IExternalWeightedMath"}],"name":"getWeightedMath","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isDisabled","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"isPoolFromFactory","inputs":[{"type":"address","name":"pool","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"version","inputs":[]}]
Contract Creation Code
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
Deployed ByteCode
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