Address Details
contract
0xE8F74deB8d5C61b12247036eda79748b50a0ceC8
- Contract Name
- Vault
- Creator
- 0xe456f9–e60f03 at 0xee44d8–4d1055
- 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
- 12171526
This contract has been verified via Sourcify.
View contract in Sourcify repository
- Contract name:
- Vault
- Optimization enabled
- true
- Compiler version
- v0.7.6+commit.7338295f
- Optimization runs
- 1500
- EVM Version
- istanbul
- Verified at
- 2022-03-28T03:23:28.491261Z
contracts/Vault.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "./interfaces/IAuthorizer.sol"; import "./interfaces/IWETH.sol"; import "./VaultAuthorization.sol"; import "./FlashLoans.sol"; import "./Swaps.sol"; /** * @dev The `Vault` is Balancer V2's core contract. A single instance of it exists for the entire network, and it is the * entity used to interact with Pools by Liquidity Providers who join and exit them, Traders who swap, and Asset * Managers who withdraw and deposit tokens. * * The `Vault`'s source code is split among a number of sub-contracts, with the goal of improving readability and making * understanding the system easier. Most sub-contracts have been marked as `abstract` to explicitly indicate that only * the full `Vault` is meant to be deployed. * * Roughly speaking, these are the contents of each sub-contract: * * - `AssetManagers`: Pool token Asset Manager registry, and Asset Manager interactions. * - `Fees`: set and compute protocol fees. * - `FlashLoans`: flash loan transfers and fees. * - `PoolBalances`: Pool joins and exits. * - `PoolRegistry`: Pool registration, ID management, and basic queries. * - `PoolTokens`: Pool token registration and registration, and balance queries. * - `Swaps`: Pool swaps. * - `UserBalance`: manage user balances (Internal Balance operations and external balance transfers) * - `VaultAuthorization`: access control, relayers and signature validation. * * Additionally, the different Pool specializations are handled by the `GeneralPoolsBalance`, * `MinimalSwapInfoPoolsBalance` and `TwoTokenPoolsBalance` sub-contracts, which in turn make use of the * `BalanceAllocation` library. * * The most important goal of the `Vault` is to make token swaps use as little gas as possible. This is reflected in a * multitude of design decisions, from minor things like the format used to store Pool IDs, to major features such as * the different Pool specialization settings. * * Finally, the large number of tasks carried out by the Vault means its bytecode is very large, close to exceeding * the contract size limit imposed by EIP 170 (https://eips.ethereum.org/EIPS/eip-170). Manual tuning of the source code * was required to improve code generation and bring the bytecode size below this limit. This includes extensive * utilization of `internal` functions (particularly inside modifiers), usage of named return arguments, dedicated * storage access methods, dynamic revert reason generation, and usage of inline assembly, to name a few. */ contract Vault is VaultAuthorization, FlashLoans, Swaps { constructor( IAuthorizer authorizer, IWETH weth, uint256 pauseWindowDuration, uint256 bufferPeriodDuration ) VaultAuthorization(authorizer) AssetHelpers(weth) TemporarilyPausable(pauseWindowDuration, bufferPeriodDuration) { // solhint-disable-previous-line no-empty-blocks } function setPaused(bool paused) external override nonReentrant authenticate { _setPaused(paused); } // solhint-disable-next-line func-name-mixedcase function WETH() external view override returns (IWETH) { return _WETH(); } }
/contracts/AssetManagers.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/math/Math.sol"; import "../lib/helpers/BalancerErrors.sol"; import "../lib/helpers/InputHelpers.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "./UserBalance.sol"; import "./balances/BalanceAllocation.sol"; import "./balances/GeneralPoolsBalance.sol"; import "./balances/MinimalSwapInfoPoolsBalance.sol"; import "./balances/TwoTokenPoolsBalance.sol"; abstract contract AssetManagers is ReentrancyGuard, GeneralPoolsBalance, MinimalSwapInfoPoolsBalance, TwoTokenPoolsBalance { using Math for uint256; using SafeERC20 for IERC20; // Stores the Asset Manager for each token of each Pool. mapping(bytes32 => mapping(IERC20 => address)) internal _poolAssetManagers; function managePoolBalance(PoolBalanceOp[] memory ops) external override nonReentrant whenNotPaused { // This variable could be declared inside the loop, but that causes the compiler to allocate memory on each // loop iteration, increasing gas costs. PoolBalanceOp memory op; for (uint256 i = 0; i < ops.length; ++i) { // By indexing the array only once, we don't spend extra gas in the same bounds check. op = ops[i]; bytes32 poolId = op.poolId; _ensureRegisteredPool(poolId); IERC20 token = op.token; _require(_isTokenRegistered(poolId, token), Errors.TOKEN_NOT_REGISTERED); _require(_poolAssetManagers[poolId][token] == msg.sender, Errors.SENDER_NOT_ASSET_MANAGER); PoolBalanceOpKind kind = op.kind; uint256 amount = op.amount; (int256 cashDelta, int256 managedDelta) = _performPoolManagementOperation(kind, poolId, token, amount); emit PoolBalanceManaged(poolId, msg.sender, token, cashDelta, managedDelta); } } /** * @dev Performs the `kind` Asset Manager operation on a Pool. * * Withdrawals will transfer `amount` tokens to the caller, deposits will transfer `amount` tokens from the caller, * and updates will set the managed balance to `amount`. * * Returns a tuple with the 'cash' and 'managed' balance deltas as a result of this call. */ function _performPoolManagementOperation( PoolBalanceOpKind kind, bytes32 poolId, IERC20 token, uint256 amount ) private returns (int256, int256) { PoolSpecialization specialization = _getPoolSpecialization(poolId); if (kind == PoolBalanceOpKind.WITHDRAW) { return _withdrawPoolBalance(poolId, specialization, token, amount); } else if (kind == PoolBalanceOpKind.DEPOSIT) { return _depositPoolBalance(poolId, specialization, token, amount); } else { // PoolBalanceOpKind.UPDATE return _updateManagedBalance(poolId, specialization, token, amount); } } /** * @dev Moves `amount` tokens from a Pool's 'cash' to 'managed' balance, and transfers them to the caller. * * Returns the 'cash' and 'managed' balance deltas as a result of this call, which will be complementary. */ function _withdrawPoolBalance( bytes32 poolId, PoolSpecialization specialization, IERC20 token, uint256 amount ) private returns (int256 cashDelta, int256 managedDelta) { if (specialization == PoolSpecialization.TWO_TOKEN) { _twoTokenPoolCashToManaged(poolId, token, amount); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { _minimalSwapInfoPoolCashToManaged(poolId, token, amount); } else { // PoolSpecialization.GENERAL _generalPoolCashToManaged(poolId, token, amount); } if (amount > 0) { token.safeTransfer(msg.sender, amount); } // Since 'cash' and 'managed' are stored as uint112, `amount` is guaranteed to also fit in 112 bits. It will // therefore always fit in a 256 bit integer. cashDelta = int256(-amount); managedDelta = int256(amount); } /** * @dev Moves `amount` tokens from a Pool's 'managed' to 'cash' balance, and transfers them from the caller. * * Returns the 'cash' and 'managed' balance deltas as a result of this call, which will be complementary. */ function _depositPoolBalance( bytes32 poolId, PoolSpecialization specialization, IERC20 token, uint256 amount ) private returns (int256 cashDelta, int256 managedDelta) { if (specialization == PoolSpecialization.TWO_TOKEN) { _twoTokenPoolManagedToCash(poolId, token, amount); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { _minimalSwapInfoPoolManagedToCash(poolId, token, amount); } else { // PoolSpecialization.GENERAL _generalPoolManagedToCash(poolId, token, amount); } if (amount > 0) { token.safeTransferFrom(msg.sender, address(this), amount); } // Since 'cash' and 'managed' are stored as uint112, `amount` is guaranteed to also fit in 112 bits. It will // therefore always fit in a 256 bit integer. cashDelta = int256(amount); managedDelta = int256(-amount); } /** * @dev Sets a Pool's 'managed' balance to `amount`. * * Returns the 'cash' and 'managed' balance deltas as a result of this call (the 'cash' delta will always be zero). */ function _updateManagedBalance( bytes32 poolId, PoolSpecialization specialization, IERC20 token, uint256 amount ) private returns (int256 cashDelta, int256 managedDelta) { if (specialization == PoolSpecialization.TWO_TOKEN) { managedDelta = _setTwoTokenPoolManagedBalance(poolId, token, amount); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { managedDelta = _setMinimalSwapInfoPoolManagedBalance(poolId, token, amount); } else { // PoolSpecialization.GENERAL managedDelta = _setGeneralPoolManagedBalance(poolId, token, amount); } cashDelta = 0; } /** * @dev Returns true if `token` is registered for `poolId`. */ function _isTokenRegistered(bytes32 poolId, IERC20 token) private view returns (bool) { PoolSpecialization specialization = _getPoolSpecialization(poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { return _isTwoTokenPoolTokenRegistered(poolId, token); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { return _isMinimalSwapInfoPoolTokenRegistered(poolId, token); } else { // PoolSpecialization.GENERAL return _isGeneralPoolTokenRegistered(poolId, token); } } }
/contracts/AssetTransfersHandler.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/math/Math.sol"; import "../lib/helpers/BalancerErrors.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/helpers/AssetHelpers.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "../lib/openzeppelin/Address.sol"; import "./interfaces/IWETH.sol"; import "./interfaces/IAsset.sol"; import "./interfaces/IVault.sol"; abstract contract AssetTransfersHandler is AssetHelpers { using SafeERC20 for IERC20; using Address for address payable; /** * @dev Receives `amount` of `asset` from `sender`. If `fromInternalBalance` is true, it first withdraws as much * as possible from Internal Balance, then transfers any remaining amount. * * If `asset` is ETH, `fromInternalBalance` must be false (as ETH cannot be held as internal balance), and the funds * will be wrapped into WETH. * * WARNING: this function does not check that the contract caller has actually supplied any ETH - it is up to the * caller of this function to check that this is true to prevent the Vault from using its own ETH (though the Vault * typically doesn't hold any). */ function _receiveAsset( IAsset asset, uint256 amount, address sender, bool fromInternalBalance ) internal { if (amount == 0) { return; } if (_isETH(asset)) { _require(!fromInternalBalance, Errors.INVALID_ETH_INTERNAL_BALANCE); // The ETH amount to receive is deposited into the WETH contract, which will in turn mint WETH for // the Vault at a 1:1 ratio. // A check for this condition is also introduced by the compiler, but this one provides a revert reason. // Note we're checking for the Vault's total balance, *not* ETH sent in this transaction. _require(address(this).balance >= amount, Errors.INSUFFICIENT_ETH); _WETH().deposit{ value: amount }(); } else { IERC20 token = _asIERC20(asset); if (fromInternalBalance) { // We take as many tokens from Internal Balance as possible: any remaining amounts will be transferred. uint256 deductedBalance = _decreaseInternalBalance(sender, token, amount, true); // Because `deductedBalance` will be always the lesser of the current internal balance // and the amount to decrease, it is safe to perform unchecked arithmetic. amount -= deductedBalance; } if (amount > 0) { token.safeTransferFrom(sender, address(this), amount); } } } /** * @dev Sends `amount` of `asset` to `recipient`. If `toInternalBalance` is true, the asset is deposited as Internal * Balance instead of being transferred. * * If `asset` is ETH, `toInternalBalance` must be false (as ETH cannot be held as internal balance), and the funds * are instead sent directly after unwrapping WETH. */ function _sendAsset( IAsset asset, uint256 amount, address payable recipient, bool toInternalBalance ) internal { if (amount == 0) { return; } if (_isETH(asset)) { // Sending ETH is not as involved as receiving it: the only special behavior is it cannot be // deposited to Internal Balance. _require(!toInternalBalance, Errors.INVALID_ETH_INTERNAL_BALANCE); // First, the Vault withdraws deposited ETH from the WETH contract, by burning the same amount of WETH // from the Vault. This receipt will be handled by the Vault's `receive`. _WETH().withdraw(amount); // Then, the withdrawn ETH is sent to the recipient. recipient.sendValue(amount); } else { IERC20 token = _asIERC20(asset); if (toInternalBalance) { _increaseInternalBalance(recipient, token, amount); } else { token.safeTransfer(recipient, amount); } } } /** * @dev Returns excess ETH back to the contract caller, assuming `amountUsed` has been spent. Reverts * if the caller sent less ETH than `amountUsed`. * * Because the caller might not know exactly how much ETH a Vault action will require, they may send extra. * Note that this excess value is returned *to the contract caller* (msg.sender). If caller and e.g. swap sender are * not the same (because the caller is a relayer for the sender), then it is up to the caller to manage this * returned ETH. */ function _handleRemainingEth(uint256 amountUsed) internal { _require(msg.value >= amountUsed, Errors.INSUFFICIENT_ETH); uint256 excess = msg.value - amountUsed; if (excess > 0) { msg.sender.sendValue(excess); } } /** * @dev Enables the Vault to receive ETH. This is required for it to be able to unwrap WETH, which sends ETH to the * caller. * * Any ETH sent to the Vault outside of the WETH unwrapping mechanism would be forever locked inside the Vault, so * we prevent that from happening. Other mechanisms used to send ETH to the Vault (such as being the recipient of an * ETH swap, Pool exit or withdrawal, contract self-destruction, or receiving the block mining reward) will result * in locked funds, but are not otherwise a security or soundness issue. This check only exists as an attempt to * prevent user error. */ receive() external payable { _require(msg.sender == address(_WETH()), Errors.ETH_TRANSFER); } // This contract uses virtual internal functions instead of inheriting from the modules that implement them (in // this case UserBalance) in order to decouple it from the rest of the system and enable standalone testing by // implementing these with mocks. function _increaseInternalBalance( address account, IERC20 token, uint256 amount ) internal virtual; function _decreaseInternalBalance( address account, IERC20 token, uint256 amount, bool capped ) internal virtual returns (uint256); }
/contracts/Fees.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/math/FixedPoint.sol"; import "../lib/helpers/BalancerErrors.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "./ProtocolFeesCollector.sol"; import "./VaultAuthorization.sol"; import "./interfaces/IVault.sol"; /** * @dev To reduce the bytecode size of the Vault, most of the protocol fee logic is not here, but in the * ProtocolFeesCollector contract. */ abstract contract Fees is IVault { using SafeERC20 for IERC20; ProtocolFeesCollector private immutable _protocolFeesCollector; constructor() { _protocolFeesCollector = new ProtocolFeesCollector(IVault(this)); } function getProtocolFeesCollector() public view override returns (ProtocolFeesCollector) { return _protocolFeesCollector; } /** * @dev Returns the protocol swap fee percentage. */ function _getProtocolSwapFeePercentage() internal view returns (uint256) { return getProtocolFeesCollector().getSwapFeePercentage(); } /** * @dev Returns the protocol fee amount to charge for a flash loan of `amount`. */ function _calculateFlashLoanFeeAmount(uint256 amount) internal view returns (uint256) { // Fixed point multiplication introduces error: we round up, which means in certain scenarios the charged // percentage can be slightly higher than intended. uint256 percentage = getProtocolFeesCollector().getFlashLoanFeePercentage(); return FixedPoint.mulUp(amount, percentage); } function _payFeeAmount(IERC20 token, uint256 amount) internal { if (amount > 0) { token.safeTransfer(address(getProtocolFeesCollector()), amount); } } }
/contracts/FlashLoans.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 flash loan provider was based on the Aave protocol's open source // implementation and terminology and interfaces are intentionally kept // similar pragma solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/helpers/BalancerErrors.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "./Fees.sol"; import "./interfaces/IFlashLoanRecipient.sol"; /** * @dev Handles Flash Loans through the Vault. Calls the `receiveFlashLoan` hook on the flash loan recipient * contract, which implements the `IFlashLoanRecipient` interface. */ abstract contract FlashLoans is Fees, ReentrancyGuard, TemporarilyPausable { using SafeERC20 for IERC20; function flashLoan( IFlashLoanRecipient recipient, IERC20[] memory tokens, uint256[] memory amounts, bytes memory userData ) external override nonReentrant whenNotPaused { InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length); uint256[] memory feeAmounts = new uint256[](tokens.length); uint256[] memory preLoanBalances = new uint256[](tokens.length); // Used to ensure `tokens` is sorted in ascending order, which ensures token uniqueness. IERC20 previousToken = IERC20(0); for (uint256 i = 0; i < tokens.length; ++i) { IERC20 token = tokens[i]; uint256 amount = amounts[i]; _require(token > previousToken, token == IERC20(0) ? Errors.ZERO_TOKEN : Errors.UNSORTED_TOKENS); previousToken = token; preLoanBalances[i] = token.balanceOf(address(this)); feeAmounts[i] = _calculateFlashLoanFeeAmount(amount); _require(preLoanBalances[i] >= amount, Errors.INSUFFICIENT_FLASH_LOAN_BALANCE); token.safeTransfer(address(recipient), amount); } recipient.receiveFlashLoan(tokens, amounts, feeAmounts, userData); for (uint256 i = 0; i < tokens.length; ++i) { IERC20 token = tokens[i]; uint256 preLoanBalance = preLoanBalances[i]; // Checking for loan repayment first (without accounting for fees) makes for simpler debugging, and results // in more accurate revert reasons if the flash loan protocol fee percentage is zero. uint256 postLoanBalance = token.balanceOf(address(this)); _require(postLoanBalance >= preLoanBalance, Errors.INVALID_POST_LOAN_BALANCE); // No need for checked arithmetic since we know the loan was fully repaid. uint256 receivedFeeAmount = postLoanBalance - preLoanBalance; _require(receivedFeeAmount >= feeAmounts[i], Errors.INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT); _payFeeAmount(token, receivedFeeAmount); emit FlashLoan(recipient, token, amounts[i], receivedFeeAmount); } } }
/contracts/PoolBalances.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/math/Math.sol"; import "../lib/helpers/BalancerErrors.sol"; import "../lib/helpers/InputHelpers.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "./Fees.sol"; import "./PoolTokens.sol"; import "./UserBalance.sol"; import "./interfaces/IBasePool.sol"; /** * @dev Stores the Asset Managers (by Pool and token), and implements the top level Asset Manager and Pool interfaces, * such as registering and deregistering tokens, joining and exiting Pools, and informational functions like `getPool` * and `getPoolTokens`, delegating to specialization-specific functions as needed. * * `managePoolBalance` handles all Asset Manager interactions. */ abstract contract PoolBalances is Fees, ReentrancyGuard, PoolTokens, UserBalance { using Math for uint256; using SafeERC20 for IERC20; using BalanceAllocation for bytes32; using BalanceAllocation for bytes32[]; function joinPool( bytes32 poolId, address sender, address recipient, JoinPoolRequest memory request ) external payable override whenNotPaused { // This function doesn't have the nonReentrant modifier: it is applied to `_joinOrExit` instead. // Note that `recipient` is not actually payable in the context of a join - we cast it because we handle both // joins and exits at once. _joinOrExit(PoolBalanceChangeKind.JOIN, poolId, sender, payable(recipient), _toPoolBalanceChange(request)); } function exitPool( bytes32 poolId, address sender, address payable recipient, ExitPoolRequest memory request ) external override { // This function doesn't have the nonReentrant modifier: it is applied to `_joinOrExit` instead. _joinOrExit(PoolBalanceChangeKind.EXIT, poolId, sender, recipient, _toPoolBalanceChange(request)); } // This has the exact same layout as JoinPoolRequest and ExitPoolRequest, except the `maxAmountsIn` and // `minAmountsOut` are called `limits`. Internally we use this struct for both since these two functions are quite // similar, but expose the others to callers for clarity. struct PoolBalanceChange { IAsset[] assets; uint256[] limits; bytes userData; bool useInternalBalance; } /** * @dev Converts a JoinPoolRequest into a PoolBalanceChange, with no runtime cost. */ function _toPoolBalanceChange(JoinPoolRequest memory request) private pure returns (PoolBalanceChange memory change) { // solhint-disable-next-line no-inline-assembly assembly { change := request } } /** * @dev Converts an ExitPoolRequest into a PoolBalanceChange, with no runtime cost. */ function _toPoolBalanceChange(ExitPoolRequest memory request) private pure returns (PoolBalanceChange memory change) { // solhint-disable-next-line no-inline-assembly assembly { change := request } } /** * @dev Implements both `joinPool` and `exitPool`, based on `kind`. */ function _joinOrExit( PoolBalanceChangeKind kind, bytes32 poolId, address sender, address payable recipient, PoolBalanceChange memory change ) private nonReentrant withRegisteredPool(poolId) authenticateFor(sender) { // This function uses a large number of stack variables (poolId, sender and recipient, balances, amounts, fees, // etc.), which leads to 'stack too deep' issues. It relies on private functions with seemingly arbitrary // interfaces to work around this limitation. InputHelpers.ensureInputLengthMatch(change.assets.length, change.limits.length); // We first check that the caller passed the Pool's registered tokens in the correct order, and retrieve the // current balance for each. IERC20[] memory tokens = _translateToIERC20(change.assets); bytes32[] memory balances = _validateTokensAndGetBalances(poolId, tokens); // The bulk of the work is done here: the corresponding Pool hook is called, its final balances are computed, // assets are transferred, and fees are paid. ( bytes32[] memory finalBalances, uint256[] memory amountsInOrOut, uint256[] memory paidProtocolSwapFeeAmounts ) = _callPoolBalanceChange(kind, poolId, sender, recipient, change, balances); // All that remains is storing the new Pool balances. PoolSpecialization specialization = _getPoolSpecialization(poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { _setTwoTokenPoolCashBalances(poolId, tokens[0], finalBalances[0], tokens[1], finalBalances[1]); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { _setMinimalSwapInfoPoolBalances(poolId, tokens, finalBalances); } else { // PoolSpecialization.GENERAL _setGeneralPoolBalances(poolId, finalBalances); } bool positive = kind == PoolBalanceChangeKind.JOIN; // Amounts in are positive, out are negative emit PoolBalanceChanged( poolId, sender, tokens, // We can unsafely cast to int256 because balances are actually stored as uint112 _unsafeCastToInt256(amountsInOrOut, positive), paidProtocolSwapFeeAmounts ); } /** * @dev Calls the corresponding Pool hook to get the amounts in/out plus protocol fee amounts, and performs the * associated token transfers and fee payments, returning the Pool's final balances. */ function _callPoolBalanceChange( PoolBalanceChangeKind kind, bytes32 poolId, address sender, address payable recipient, PoolBalanceChange memory change, bytes32[] memory balances ) private returns ( bytes32[] memory finalBalances, uint256[] memory amountsInOrOut, uint256[] memory dueProtocolFeeAmounts ) { (uint256[] memory totalBalances, uint256 lastChangeBlock) = balances.totalsAndLastChangeBlock(); IBasePool pool = IBasePool(_getPoolAddress(poolId)); (amountsInOrOut, dueProtocolFeeAmounts) = kind == PoolBalanceChangeKind.JOIN ? pool.onJoinPool( poolId, sender, recipient, totalBalances, lastChangeBlock, _getProtocolSwapFeePercentage(), change.userData ) : pool.onExitPool( poolId, sender, recipient, totalBalances, lastChangeBlock, _getProtocolSwapFeePercentage(), change.userData ); InputHelpers.ensureInputLengthMatch(balances.length, amountsInOrOut.length, dueProtocolFeeAmounts.length); // The Vault ignores the `recipient` in joins and the `sender` in exits: it is up to the Pool to keep track of // their participation. finalBalances = kind == PoolBalanceChangeKind.JOIN ? _processJoinPoolTransfers(sender, change, balances, amountsInOrOut, dueProtocolFeeAmounts) : _processExitPoolTransfers(recipient, change, balances, amountsInOrOut, dueProtocolFeeAmounts); } /** * @dev Transfers `amountsIn` from `sender`, checking that they are within their accepted limits, and pays * accumulated protocol swap fees. * * Returns the Pool's final balances, which are the current balances plus `amountsIn` minus accumulated protocol * swap fees. */ function _processJoinPoolTransfers( address sender, PoolBalanceChange memory change, bytes32[] memory balances, uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts ) private returns (bytes32[] memory finalBalances) { // We need to track how much of the received ETH was used and wrapped into WETH to return any excess. uint256 wrappedEth = 0; finalBalances = new bytes32[](balances.length); for (uint256 i = 0; i < change.assets.length; ++i) { uint256 amountIn = amountsIn[i]; _require(amountIn <= change.limits[i], Errors.JOIN_ABOVE_MAX); // Receive assets from the sender - possibly from Internal Balance. IAsset asset = change.assets[i]; _receiveAsset(asset, amountIn, sender, change.useInternalBalance); if (_isETH(asset)) { wrappedEth = wrappedEth.add(amountIn); } uint256 feeAmount = dueProtocolFeeAmounts[i]; _payFeeAmount(_translateToIERC20(asset), feeAmount); // Compute the new Pool balances. Note that the fee amount might be larger than `amountIn`, // resulting in an overall decrease of the Pool's balance for a token. finalBalances[i] = (amountIn >= feeAmount) // This lets us skip checked arithmetic ? balances[i].increaseCash(amountIn - feeAmount) : balances[i].decreaseCash(feeAmount - amountIn); } // Handle any used and remaining ETH. _handleRemainingEth(wrappedEth); } /** * @dev Transfers `amountsOut` to `recipient`, checking that they are within their accepted limits, and pays * accumulated protocol swap fees from the Pool. * * Returns the Pool's final balances, which are the current `balances` minus `amountsOut` and fees paid * (`dueProtocolFeeAmounts`). */ function _processExitPoolTransfers( address payable recipient, PoolBalanceChange memory change, bytes32[] memory balances, uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts ) private returns (bytes32[] memory finalBalances) { finalBalances = new bytes32[](balances.length); for (uint256 i = 0; i < change.assets.length; ++i) { uint256 amountOut = amountsOut[i]; _require(amountOut >= change.limits[i], Errors.EXIT_BELOW_MIN); // Send tokens to the recipient - possibly to Internal Balance IAsset asset = change.assets[i]; _sendAsset(asset, amountOut, recipient, change.useInternalBalance); uint256 feeAmount = dueProtocolFeeAmounts[i]; _payFeeAmount(_translateToIERC20(asset), feeAmount); // Compute the new Pool balances. A Pool's token balance always decreases after an exit (potentially by 0). finalBalances[i] = balances[i].decreaseCash(amountOut.add(feeAmount)); } } /** * @dev Returns the total balance for `poolId`'s `expectedTokens`. * * `expectedTokens` must exactly equal the token array returned by `getPoolTokens`: both arrays must have the same * length, elements and order. Additionally, the Pool must have at least one registered token. */ function _validateTokensAndGetBalances(bytes32 poolId, IERC20[] memory expectedTokens) private view returns (bytes32[] memory) { (IERC20[] memory actualTokens, bytes32[] memory balances) = _getPoolTokens(poolId); InputHelpers.ensureInputLengthMatch(actualTokens.length, expectedTokens.length); _require(actualTokens.length > 0, Errors.POOL_NO_TOKENS); for (uint256 i = 0; i < actualTokens.length; ++i) { _require(actualTokens[i] == expectedTokens[i], Errors.TOKENS_MISMATCH); } return balances; } /** * @dev Casts an array of uint256 to int256, setting the sign of the result according to the `positive` flag, * without checking whether the values fit in the signed 256 bit range. */ function _unsafeCastToInt256(uint256[] memory values, bool positive) private pure returns (int256[] memory signedValues) { signedValues = new int256[](values.length); for (uint256 i = 0; i < values.length; i++) { signedValues[i] = positive ? int256(values[i]) : -int256(values[i]); } } }
/contracts/PoolRegistry.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/helpers/BalancerErrors.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "./VaultAuthorization.sol"; /** * @dev Maintains the Pool ID data structure, implements Pool ID creation and registration, and defines useful modifiers * and helper functions for ensuring correct behavior when working with Pools. */ abstract contract PoolRegistry is ReentrancyGuard, VaultAuthorization { // Each pool is represented by their unique Pool ID. We use `bytes32` for them, for lack of a way to define new // types. mapping(bytes32 => bool) private _isPoolRegistered; // We keep an increasing nonce to make Pool IDs unique. It is interpreted as a `uint80`, but storing it as a // `uint256` results in reduced bytecode on reads and writes due to the lack of masking. uint256 private _nextPoolNonce; /** * @dev Reverts unless `poolId` corresponds to a registered Pool. */ modifier withRegisteredPool(bytes32 poolId) { _ensureRegisteredPool(poolId); _; } /** * @dev Reverts unless `poolId` corresponds to a registered Pool, and the caller is the Pool's contract. */ modifier onlyPool(bytes32 poolId) { _ensurePoolIsSender(poolId); _; } /** * @dev Reverts unless `poolId` corresponds to a registered Pool. */ function _ensureRegisteredPool(bytes32 poolId) internal view { _require(_isPoolRegistered[poolId], Errors.INVALID_POOL_ID); } /** * @dev Reverts unless `poolId` corresponds to a registered Pool, and the caller is the Pool's contract. */ function _ensurePoolIsSender(bytes32 poolId) private view { _ensureRegisteredPool(poolId); _require(msg.sender == _getPoolAddress(poolId), Errors.CALLER_NOT_POOL); } function registerPool(PoolSpecialization specialization) external override nonReentrant whenNotPaused returns (bytes32) { // Each Pool is assigned a unique ID based on an incrementing nonce. This assumes there will never be more than // 2**80 Pools, and the nonce will not overflow. bytes32 poolId = _toPoolId(msg.sender, specialization, uint80(_nextPoolNonce)); _require(!_isPoolRegistered[poolId], Errors.INVALID_POOL_ID); // Should never happen as Pool IDs are unique. _isPoolRegistered[poolId] = true; _nextPoolNonce += 1; // Note that msg.sender is the pool's contract emit PoolRegistered(poolId, msg.sender, specialization); return poolId; } function getPool(bytes32 poolId) external view override withRegisteredPool(poolId) returns (address, PoolSpecialization) { return (_getPoolAddress(poolId), _getPoolSpecialization(poolId)); } /** * @dev Creates a Pool ID. * * These are deterministically created by packing the Pool's contract address and its specialization setting into * the ID. This saves gas by making this data easily retrievable from a Pool ID with no storage accesses. * * Since a single contract can register multiple Pools, a unique nonce must be provided to ensure Pool IDs are * unique. * * Pool IDs have the following layout: * | 20 bytes pool contract address | 2 bytes specialization setting | 10 bytes nonce | * MSB LSB * * 2 bytes for the specialization setting is a bit overkill: there only three of them, which means two bits would * suffice. However, there's nothing else of interest to store in this extra space. */ function _toPoolId( address pool, PoolSpecialization specialization, uint80 nonce ) internal pure returns (bytes32) { bytes32 serialized; serialized |= bytes32(uint256(nonce)); serialized |= bytes32(uint256(specialization)) << (10 * 8); serialized |= bytes32(uint256(pool)) << (12 * 8); return serialized; } /** * @dev Returns the address of a Pool's contract. * * Due to how Pool IDs are created, this is done with no storage accesses and costs little gas. */ function _getPoolAddress(bytes32 poolId) internal pure returns (address) { // 12 byte logical shift left to remove the nonce and specialization setting. We don't need to mask, // since the logical shift already sets the upper bits to zero. return address(uint256(poolId) >> (12 * 8)); } /** * @dev Returns the specialization setting of a Pool. * * Due to how Pool IDs are created, this is done with no storage accesses and costs little gas. */ function _getPoolSpecialization(bytes32 poolId) internal pure returns (PoolSpecialization specialization) { // 10 byte logical shift left to remove the nonce, followed by a 2 byte mask to remove the address. uint256 value = uint256(poolId >> (10 * 8)) & (2**(2 * 8) - 1); // Casting a value into an enum results in a runtime check that reverts unless the value is within the enum's // range. Passing an invalid Pool ID to this function would then result in an obscure revert with no reason // string: we instead perform the check ourselves to help in error diagnosis. // There are three Pool specialization settings: general, minimal swap info and two tokens, which correspond to // values 0, 1 and 2. _require(value < 3, Errors.INVALID_POOL_ID); // Because we have checked that `value` is within the enum range, we can use assembly to skip the runtime check. // solhint-disable-next-line no-inline-assembly assembly { specialization := value } } }
/contracts/PoolTokens.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/helpers/BalancerErrors.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "./AssetManagers.sol"; import "./PoolRegistry.sol"; import "./balances/BalanceAllocation.sol"; abstract contract PoolTokens is ReentrancyGuard, PoolRegistry, AssetManagers { using BalanceAllocation for bytes32; using BalanceAllocation for bytes32[]; function registerTokens( bytes32 poolId, IERC20[] memory tokens, address[] memory assetManagers ) external override nonReentrant whenNotPaused onlyPool(poolId) { InputHelpers.ensureInputLengthMatch(tokens.length, assetManagers.length); // Validates token addresses and assigns Asset Managers for (uint256 i = 0; i < tokens.length; ++i) { IERC20 token = tokens[i]; _require(token != IERC20(0), Errors.INVALID_TOKEN); _poolAssetManagers[poolId][token] = assetManagers[i]; } PoolSpecialization specialization = _getPoolSpecialization(poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { _require(tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2); _registerTwoTokenPoolTokens(poolId, tokens[0], tokens[1]); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { _registerMinimalSwapInfoPoolTokens(poolId, tokens); } else { // PoolSpecialization.GENERAL _registerGeneralPoolTokens(poolId, tokens); } emit TokensRegistered(poolId, tokens, assetManagers); } function deregisterTokens(bytes32 poolId, IERC20[] memory tokens) external override nonReentrant whenNotPaused onlyPool(poolId) { PoolSpecialization specialization = _getPoolSpecialization(poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { _require(tokens.length == 2, Errors.TOKENS_LENGTH_MUST_BE_2); _deregisterTwoTokenPoolTokens(poolId, tokens[0], tokens[1]); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { _deregisterMinimalSwapInfoPoolTokens(poolId, tokens); } else { // PoolSpecialization.GENERAL _deregisterGeneralPoolTokens(poolId, tokens); } // The deregister calls above ensure the total token balance is zero. Therefore it is now safe to remove any // associated Asset Managers, since they hold no Pool balance. for (uint256 i = 0; i < tokens.length; ++i) { delete _poolAssetManagers[poolId][tokens[i]]; } emit TokensDeregistered(poolId, tokens); } function getPoolTokens(bytes32 poolId) external view override withRegisteredPool(poolId) returns ( IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock ) { bytes32[] memory rawBalances; (tokens, rawBalances) = _getPoolTokens(poolId); (balances, lastChangeBlock) = rawBalances.totalsAndLastChangeBlock(); } function getPoolTokenInfo(bytes32 poolId, IERC20 token) external view override withRegisteredPool(poolId) returns ( uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager ) { bytes32 balance; PoolSpecialization specialization = _getPoolSpecialization(poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { balance = _getTwoTokenPoolBalance(poolId, token); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { balance = _getMinimalSwapInfoPoolBalance(poolId, token); } else { // PoolSpecialization.GENERAL balance = _getGeneralPoolBalance(poolId, token); } cash = balance.cash(); managed = balance.managed(); lastChangeBlock = balance.lastChangeBlock(); assetManager = _poolAssetManagers[poolId][token]; } /** * @dev Returns all of `poolId`'s registered tokens, along with their raw balances. */ function _getPoolTokens(bytes32 poolId) internal view returns (IERC20[] memory tokens, bytes32[] memory balances) { PoolSpecialization specialization = _getPoolSpecialization(poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { return _getTwoTokenPoolTokens(poolId); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { return _getMinimalSwapInfoPoolTokens(poolId); } else { // PoolSpecialization.GENERAL return _getGeneralPoolTokens(poolId); } } }
/contracts/ProtocolFeesCollector.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/openzeppelin/IERC20.sol"; import "../lib/helpers/InputHelpers.sol"; import "../lib/helpers/Authentication.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "./interfaces/IVault.sol"; import "./interfaces/IAuthorizer.sol"; /** * @dev This an auxiliary contract to the Vault, deployed by it during construction. It offloads some of the tasks the * Vault performs to reduce its overall bytecode size. * * The current values for all protocol fee percentages are stored here, and any tokens charged as protocol fees are * sent to this contract, where they may be withdrawn by authorized entities. All authorization tasks are delegated * to the Vault's own authorizer. */ contract ProtocolFeesCollector is Authentication, ReentrancyGuard { using SafeERC20 for IERC20; // Absolute maximum fee percentages (1e18 = 100%, 1e16 = 1%). uint256 private constant _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE = 50e16; // 50% uint256 private constant _MAX_PROTOCOL_FLASH_LOAN_FEE_PERCENTAGE = 1e16; // 1% IVault public immutable vault; // All fee percentages are 18-decimal fixed point numbers. // The swap fee is charged whenever a swap occurs, as a percentage of the fee charged by the Pool. These are not // actually charged on each individual swap: the `Vault` relies on the Pools being honest and reporting fees due // when users join and exit them. uint256 private _swapFeePercentage; // The flash loan fee is charged whenever a flash loan occurs, as a percentage of the tokens lent. uint256 private _flashLoanFeePercentage; event SwapFeePercentageChanged(uint256 newSwapFeePercentage); event FlashLoanFeePercentageChanged(uint256 newFlashLoanFeePercentage); constructor(IVault _vault) // The ProtocolFeesCollector is a singleton, so it simply uses its own address to disambiguate action // identifiers. Authentication(bytes32(uint256(address(this)))) { vault = _vault; } function withdrawCollectedFees( IERC20[] calldata tokens, uint256[] calldata amounts, address recipient ) external nonReentrant authenticate { InputHelpers.ensureInputLengthMatch(tokens.length, amounts.length); for (uint256 i = 0; i < tokens.length; ++i) { IERC20 token = tokens[i]; uint256 amount = amounts[i]; token.safeTransfer(recipient, amount); } } function setSwapFeePercentage(uint256 newSwapFeePercentage) external authenticate { _require(newSwapFeePercentage <= _MAX_PROTOCOL_SWAP_FEE_PERCENTAGE, Errors.SWAP_FEE_PERCENTAGE_TOO_HIGH); _swapFeePercentage = newSwapFeePercentage; emit SwapFeePercentageChanged(newSwapFeePercentage); } function setFlashLoanFeePercentage(uint256 newFlashLoanFeePercentage) external authenticate { _require( newFlashLoanFeePercentage <= _MAX_PROTOCOL_FLASH_LOAN_FEE_PERCENTAGE, Errors.FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH ); _flashLoanFeePercentage = newFlashLoanFeePercentage; emit FlashLoanFeePercentageChanged(newFlashLoanFeePercentage); } function getSwapFeePercentage() external view returns (uint256) { return _swapFeePercentage; } function getFlashLoanFeePercentage() external view returns (uint256) { return _flashLoanFeePercentage; } function getCollectedFeeAmounts(IERC20[] memory tokens) external view returns (uint256[] memory feeAmounts) { feeAmounts = new uint256[](tokens.length); for (uint256 i = 0; i < tokens.length; ++i) { feeAmounts[i] = tokens[i].balanceOf(address(this)); } } function getAuthorizer() external view returns (IAuthorizer) { return _getAuthorizer(); } function _canPerform(bytes32 actionId, address account) internal view override returns (bool) { return _getAuthorizer().canPerform(actionId, account, address(this)); } function _getAuthorizer() internal view returns (IAuthorizer) { return vault.getAuthorizer(); } }
/contracts/Swaps.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/math/Math.sol"; import "../lib/helpers/BalancerErrors.sol"; import "../lib/helpers/InputHelpers.sol"; import "../lib/openzeppelin/EnumerableMap.sol"; import "../lib/openzeppelin/EnumerableSet.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "../lib/openzeppelin/SafeCast.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "./PoolBalances.sol"; import "./interfaces/IPoolSwapStructs.sol"; import "./interfaces/IGeneralPool.sol"; import "./interfaces/IMinimalSwapInfoPool.sol"; import "./balances/BalanceAllocation.sol"; /** * Implements the Vault's high-level swap functionality. * * Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. They need not trust the Pool * contracts to do this: all security checks are made by the Vault. * * The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence. * In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'), * and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out'). * More complex swaps, such as one 'token in' to multiple tokens out can be achieved by batching together * individual swaps. */ abstract contract Swaps is ReentrancyGuard, PoolBalances { using SafeERC20 for IERC20; using EnumerableSet for EnumerableSet.AddressSet; using EnumerableMap for EnumerableMap.IERC20ToBytes32Map; using Math for int256; using Math for uint256; using SafeCast for uint256; using BalanceAllocation for bytes32; function swap( SingleSwap memory singleSwap, FundManagement memory funds, uint256 limit, uint256 deadline ) external payable override nonReentrant whenNotPaused authenticateFor(funds.sender) returns (uint256 amountCalculated) { // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy. // solhint-disable-next-line not-rely-on-time _require(block.timestamp <= deadline, Errors.SWAP_DEADLINE); // This revert reason is for consistency with `batchSwap`: an equivalent `swap` performed using that function // would result in this error. _require(singleSwap.amount > 0, Errors.UNKNOWN_AMOUNT_IN_FIRST_SWAP); IERC20 tokenIn = _translateToIERC20(singleSwap.assetIn); IERC20 tokenOut = _translateToIERC20(singleSwap.assetOut); _require(tokenIn != tokenOut, Errors.CANNOT_SWAP_SAME_TOKEN); // Initializing each struct field one-by-one uses less gas than setting all at once. IPoolSwapStructs.SwapRequest memory poolRequest; poolRequest.poolId = singleSwap.poolId; poolRequest.kind = singleSwap.kind; poolRequest.tokenIn = tokenIn; poolRequest.tokenOut = tokenOut; poolRequest.amount = singleSwap.amount; poolRequest.userData = singleSwap.userData; poolRequest.from = funds.sender; poolRequest.to = funds.recipient; // The lastChangeBlock field is left uninitialized. uint256 amountIn; uint256 amountOut; (amountCalculated, amountIn, amountOut) = _swapWithPool(poolRequest); _require(singleSwap.kind == SwapKind.GIVEN_IN ? amountOut >= limit : amountIn <= limit, Errors.SWAP_LIMIT); _receiveAsset(singleSwap.assetIn, amountIn, funds.sender, funds.fromInternalBalance); _sendAsset(singleSwap.assetOut, amountOut, funds.recipient, funds.toInternalBalance); // If the asset in is ETH, then `amountIn` ETH was wrapped into WETH. _handleRemainingEth(_isETH(singleSwap.assetIn) ? amountIn : 0); } function batchSwap( SwapKind kind, BatchSwapStep[] memory swaps, IAsset[] memory assets, FundManagement memory funds, int256[] memory limits, uint256 deadline ) external payable override nonReentrant whenNotPaused authenticateFor(funds.sender) returns (int256[] memory assetDeltas) { // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy. // solhint-disable-next-line not-rely-on-time _require(block.timestamp <= deadline, Errors.SWAP_DEADLINE); InputHelpers.ensureInputLengthMatch(assets.length, limits.length); // Perform the swaps, updating the Pool token balances and computing the net Vault asset deltas. assetDeltas = _swapWithPools(swaps, assets, funds, kind); // Process asset deltas, by either transferring assets from the sender (for positive deltas) or to the recipient // (for negative deltas). uint256 wrappedEth = 0; for (uint256 i = 0; i < assets.length; ++i) { IAsset asset = assets[i]; int256 delta = assetDeltas[i]; _require(delta <= limits[i], Errors.SWAP_LIMIT); if (delta > 0) { uint256 toReceive = uint256(delta); _receiveAsset(asset, toReceive, funds.sender, funds.fromInternalBalance); if (_isETH(asset)) { wrappedEth = wrappedEth.add(toReceive); } } else if (delta < 0) { uint256 toSend = uint256(-delta); _sendAsset(asset, toSend, funds.recipient, funds.toInternalBalance); } } // Handle any used and remaining ETH. _handleRemainingEth(wrappedEth); } // For `_swapWithPools` to handle both 'given in' and 'given out' swaps, it internally tracks the 'given' amount // (supplied by the caller), and the 'calculated' amount (returned by the Pool in response to the swap request). /** * @dev Given the two swap tokens and the swap kind, returns which one is the 'given' token (the token whose * amount is supplied by the caller). */ function _tokenGiven( SwapKind kind, IERC20 tokenIn, IERC20 tokenOut ) private pure returns (IERC20) { return kind == SwapKind.GIVEN_IN ? tokenIn : tokenOut; } /** * @dev Given the two swap tokens and the swap kind, returns which one is the 'calculated' token (the token whose * amount is calculated by the Pool). */ function _tokenCalculated( SwapKind kind, IERC20 tokenIn, IERC20 tokenOut ) private pure returns (IERC20) { return kind == SwapKind.GIVEN_IN ? tokenOut : tokenIn; } /** * @dev Returns an ordered pair (amountIn, amountOut) given the 'given' and 'calculated' amounts, and the swap kind. */ function _getAmounts( SwapKind kind, uint256 amountGiven, uint256 amountCalculated ) private pure returns (uint256 amountIn, uint256 amountOut) { if (kind == SwapKind.GIVEN_IN) { (amountIn, amountOut) = (amountGiven, amountCalculated); } else { // SwapKind.GIVEN_OUT (amountIn, amountOut) = (amountCalculated, amountGiven); } } /** * @dev Performs all `swaps`, calling swap hooks on the Pool contracts and updating their balances. Does not cause * any transfer of tokens - instead it returns the net Vault token deltas: positive if the Vault should receive * tokens, and negative if it should send them. */ function _swapWithPools( BatchSwapStep[] memory swaps, IAsset[] memory assets, FundManagement memory funds, SwapKind kind ) private returns (int256[] memory assetDeltas) { assetDeltas = new int256[](assets.length); // These variables could be declared inside the loop, but that causes the compiler to allocate memory on each // loop iteration, increasing gas costs. BatchSwapStep memory batchSwapStep; IPoolSwapStructs.SwapRequest memory poolRequest; // These store data about the previous swap here to implement multihop logic across swaps. IERC20 previousTokenCalculated; uint256 previousAmountCalculated; for (uint256 i = 0; i < swaps.length; ++i) { batchSwapStep = swaps[i]; bool withinBounds = batchSwapStep.assetInIndex < assets.length && batchSwapStep.assetOutIndex < assets.length; _require(withinBounds, Errors.OUT_OF_BOUNDS); IERC20 tokenIn = _translateToIERC20(assets[batchSwapStep.assetInIndex]); IERC20 tokenOut = _translateToIERC20(assets[batchSwapStep.assetOutIndex]); _require(tokenIn != tokenOut, Errors.CANNOT_SWAP_SAME_TOKEN); // Sentinel value for multihop logic if (batchSwapStep.amount == 0) { // When the amount given is zero, we use the calculated amount for the previous swap, as long as the // current swap's given token is the previous calculated token. This makes it possible to swap a // given amount of token A for token B, and then use the resulting token B amount to swap for token C. _require(i > 0, Errors.UNKNOWN_AMOUNT_IN_FIRST_SWAP); bool usingPreviousToken = previousTokenCalculated == _tokenGiven(kind, tokenIn, tokenOut); _require(usingPreviousToken, Errors.MALCONSTRUCTED_MULTIHOP_SWAP); batchSwapStep.amount = previousAmountCalculated; } // Initializing each struct field one-by-one uses less gas than setting all at once poolRequest.poolId = batchSwapStep.poolId; poolRequest.kind = kind; poolRequest.tokenIn = tokenIn; poolRequest.tokenOut = tokenOut; poolRequest.amount = batchSwapStep.amount; poolRequest.userData = batchSwapStep.userData; poolRequest.from = funds.sender; poolRequest.to = funds.recipient; // The lastChangeBlock field is left uninitialized uint256 amountIn; uint256 amountOut; (previousAmountCalculated, amountIn, amountOut) = _swapWithPool(poolRequest); previousTokenCalculated = _tokenCalculated(kind, tokenIn, tokenOut); // Accumulate Vault deltas across swaps assetDeltas[batchSwapStep.assetInIndex] = assetDeltas[batchSwapStep.assetInIndex].add(amountIn.toInt256()); assetDeltas[batchSwapStep.assetOutIndex] = assetDeltas[batchSwapStep.assetOutIndex].sub( amountOut.toInt256() ); } } /** * @dev Performs a swap according to the parameters specified in `request`, calling the Pool's contract hook and * updating the Pool's balance. * * Returns the amount of tokens going into or out of the Vault as a result of this swap, depending on the swap kind. */ function _swapWithPool(IPoolSwapStructs.SwapRequest memory request) private returns ( uint256 amountCalculated, uint256 amountIn, uint256 amountOut ) { // Get the calculated amount from the Pool and update its balances address pool = _getPoolAddress(request.poolId); PoolSpecialization specialization = _getPoolSpecialization(request.poolId); if (specialization == PoolSpecialization.TWO_TOKEN) { amountCalculated = _processTwoTokenPoolSwapRequest(request, IMinimalSwapInfoPool(pool)); } else if (specialization == PoolSpecialization.MINIMAL_SWAP_INFO) { amountCalculated = _processMinimalSwapInfoPoolSwapRequest(request, IMinimalSwapInfoPool(pool)); } else { // PoolSpecialization.GENERAL amountCalculated = _processGeneralPoolSwapRequest(request, IGeneralPool(pool)); } (amountIn, amountOut) = _getAmounts(request.kind, request.amount, amountCalculated); emit Swap(request.poolId, request.tokenIn, request.tokenOut, amountIn, amountOut); } function _processTwoTokenPoolSwapRequest(IPoolSwapStructs.SwapRequest memory request, IMinimalSwapInfoPool pool) private returns (uint256 amountCalculated) { // For gas efficiency reasons, this function uses low-level knowledge of how Two Token Pool balances are // stored internally, instead of using getters and setters for all operations. ( bytes32 tokenABalance, bytes32 tokenBBalance, TwoTokenPoolBalances storage poolBalances ) = _getTwoTokenPoolSharedBalances(request.poolId, request.tokenIn, request.tokenOut); // We have the two Pool balances, but we don't know which one is 'token in' or 'token out'. bytes32 tokenInBalance; bytes32 tokenOutBalance; // In Two Token Pools, token A has a smaller address than token B if (request.tokenIn < request.tokenOut) { // in is A, out is B tokenInBalance = tokenABalance; tokenOutBalance = tokenBBalance; } else { // in is B, out is A tokenOutBalance = tokenABalance; tokenInBalance = tokenBBalance; } // Perform the swap request and compute the new balances for 'token in' and 'token out' after the swap (tokenInBalance, tokenOutBalance, amountCalculated) = _callMinimalSwapInfoPoolOnSwapHook( request, pool, tokenInBalance, tokenOutBalance ); // We check the token ordering again to create the new shared cash packed struct poolBalances.sharedCash = request.tokenIn < request.tokenOut ? BalanceAllocation.toSharedCash(tokenInBalance, tokenOutBalance) // in is A, out is B : BalanceAllocation.toSharedCash(tokenOutBalance, tokenInBalance); // in is B, out is A } function _processMinimalSwapInfoPoolSwapRequest( IPoolSwapStructs.SwapRequest memory request, IMinimalSwapInfoPool pool ) private returns (uint256 amountCalculated) { bytes32 tokenInBalance = _getMinimalSwapInfoPoolBalance(request.poolId, request.tokenIn); bytes32 tokenOutBalance = _getMinimalSwapInfoPoolBalance(request.poolId, request.tokenOut); // Perform the swap request and compute the new balances for 'token in' and 'token out' after the swap (tokenInBalance, tokenOutBalance, amountCalculated) = _callMinimalSwapInfoPoolOnSwapHook( request, pool, tokenInBalance, tokenOutBalance ); _minimalSwapInfoPoolsBalances[request.poolId][request.tokenIn] = tokenInBalance; _minimalSwapInfoPoolsBalances[request.poolId][request.tokenOut] = tokenOutBalance; } /** * @dev Calls the onSwap hook for a Pool that implements IMinimalSwapInfoPool: both Minimal Swap Info and Two Token * Pools do this. */ function _callMinimalSwapInfoPoolOnSwapHook( IPoolSwapStructs.SwapRequest memory request, IMinimalSwapInfoPool pool, bytes32 tokenInBalance, bytes32 tokenOutBalance ) internal returns ( bytes32 newTokenInBalance, bytes32 newTokenOutBalance, uint256 amountCalculated ) { uint256 tokenInTotal = tokenInBalance.total(); uint256 tokenOutTotal = tokenOutBalance.total(); request.lastChangeBlock = Math.max(tokenInBalance.lastChangeBlock(), tokenOutBalance.lastChangeBlock()); // Perform the swap request callback, and compute the new balances for 'token in' and 'token out' after the swap amountCalculated = pool.onSwap(request, tokenInTotal, tokenOutTotal); (uint256 amountIn, uint256 amountOut) = _getAmounts(request.kind, request.amount, amountCalculated); newTokenInBalance = tokenInBalance.increaseCash(amountIn); newTokenOutBalance = tokenOutBalance.decreaseCash(amountOut); } function _processGeneralPoolSwapRequest(IPoolSwapStructs.SwapRequest memory request, IGeneralPool pool) private returns (uint256 amountCalculated) { bytes32 tokenInBalance; bytes32 tokenOutBalance; // We access both token indexes without checking existence, because we will do it manually immediately after. EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[request.poolId]; uint256 indexIn = poolBalances.unchecked_indexOf(request.tokenIn); uint256 indexOut = poolBalances.unchecked_indexOf(request.tokenOut); if (indexIn == 0 || indexOut == 0) { // The tokens might not be registered because the Pool itself is not registered. We check this to provide a // more accurate revert reason. _ensureRegisteredPool(request.poolId); _revert(Errors.TOKEN_NOT_REGISTERED); } // EnumerableMap stores indices *plus one* to use the zero index as a sentinel value - because these are valid, // we can undo this. indexIn -= 1; indexOut -= 1; uint256 tokenAmount = poolBalances.length(); uint256[] memory currentBalances = new uint256[](tokenAmount); request.lastChangeBlock = 0; for (uint256 i = 0; i < tokenAmount; i++) { // Because the iteration is bounded by `tokenAmount`, and no tokens are registered or deregistered here, we // know `i` is a valid token index and can use `unchecked_valueAt` to save storage reads. bytes32 balance = poolBalances.unchecked_valueAt(i); currentBalances[i] = balance.total(); request.lastChangeBlock = Math.max(request.lastChangeBlock, balance.lastChangeBlock()); if (i == indexIn) { tokenInBalance = balance; } else if (i == indexOut) { tokenOutBalance = balance; } } // Perform the swap request callback and compute the new balances for 'token in' and 'token out' after the swap amountCalculated = pool.onSwap(request, currentBalances, indexIn, indexOut); (uint256 amountIn, uint256 amountOut) = _getAmounts(request.kind, request.amount, amountCalculated); tokenInBalance = tokenInBalance.increaseCash(amountIn); tokenOutBalance = tokenOutBalance.decreaseCash(amountOut); // Because no tokens were registered or deregistered between now or when we retrieved the indexes for // 'token in' and 'token out', we can use `unchecked_setAt` to save storage reads. poolBalances.unchecked_setAt(indexIn, tokenInBalance); poolBalances.unchecked_setAt(indexOut, tokenOutBalance); } // This function is not marked as `nonReentrant` because the underlying mechanism relies on reentrancy function queryBatchSwap( SwapKind kind, BatchSwapStep[] memory swaps, IAsset[] memory assets, FundManagement memory funds ) external override returns (int256[] memory) { // In order to accurately 'simulate' swaps, this function actually does perform the swaps, including calling the // Pool hooks and updating balances in storage. However, once it computes the final Vault Deltas, it // reverts unconditionally, returning this array as the revert data. // // By wrapping this reverting call, we can decode the deltas 'returned' and return them as a normal Solidity // function would. The only caveat is the function becomes non-view, but off-chain clients can still call it // via eth_call to get the expected result. // // This technique was inspired by the work from the Gnosis team in the Gnosis Safe contract: // https://github.com/gnosis/safe-contracts/blob/v1.2.0/contracts/GnosisSafe.sol#L265 // // Most of this function is implemented using inline assembly, as the actual work it needs to do is not // significant, and Solidity is not particularly well-suited to generate this behavior, resulting in a large // amount of generated bytecode. if (msg.sender != address(this)) { // We perform an external call to ourselves, forwarding the same calldata. In this call, the else clause of // the preceding if statement will be executed instead. // solhint-disable-next-line avoid-low-level-calls (bool success, ) = address(this).call(msg.data); // solhint-disable-next-line no-inline-assembly assembly { // This call should always revert to decode the actual asset deltas from the revert reason switch success case 0 { // Note we are manually writing the memory slot 0. We can safely overwrite whatever is // stored there as we take full control of the execution and then immediately return. // We copy the first 4 bytes to check if it matches with the expected signature, otherwise // there was another revert reason and we should forward it. returndatacopy(0, 0, 0x04) let error := and(mload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000) // If the first 4 bytes don't match with the expected signature, we forward the revert reason. if eq(eq(error, 0xfa61cc1200000000000000000000000000000000000000000000000000000000), 0) { returndatacopy(0, 0, returndatasize()) revert(0, returndatasize()) } // The returndata contains the signature, followed by the raw memory representation of an array: // length + data. We need to return an ABI-encoded representation of this array. // An ABI-encoded array contains an additional field when compared to its raw memory // representation: an offset to the location of the length. The offset itself is 32 bytes long, // so the smallest value we can use is 32 for the data to be located immediately after it. mstore(0, 32) // We now copy the raw memory array from returndata into memory. Since the offset takes up 32 // bytes, we start copying at address 0x20. We also get rid of the error signature, which takes // the first four bytes of returndata. let size := sub(returndatasize(), 0x04) returndatacopy(0x20, 0x04, size) // We finally return the ABI-encoded array, which has a total length equal to that of the array // (returndata), plus the 32 bytes for the offset. return(0, add(size, 32)) } default { // This call should always revert, but we fail nonetheless if that didn't happen invalid() } } } else { int256[] memory deltas = _swapWithPools(swaps, assets, funds, kind); // solhint-disable-next-line no-inline-assembly assembly { // We will return a raw representation of the array in memory, which is composed of a 32 byte length, // followed by the 32 byte int256 values. Because revert expects a size in bytes, we multiply the array // length (stored at `deltas`) by 32. let size := mul(mload(deltas), 32) // We send one extra value for the error signature "QueryError(int256[])" which is 0xfa61cc12. // We store it in the previous slot to the `deltas` array. We know there will be at least one available // slot due to how the memory scratch space works. // We can safely overwrite whatever is stored in this slot as we will revert immediately after that. mstore(sub(deltas, 0x20), 0x00000000000000000000000000000000000000000000000000000000fa61cc12) let start := sub(deltas, 0x04) // When copying from `deltas` into returndata, we copy an additional 36 bytes to also return the array's // length and the error signature. revert(start, add(size, 36)) } } } }
/contracts/UserBalance.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/helpers/BalancerErrors.sol"; import "../lib/math/Math.sol"; import "../lib/openzeppelin/IERC20.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "../lib/openzeppelin/SafeCast.sol"; import "../lib/openzeppelin/SafeERC20.sol"; import "./AssetTransfersHandler.sol"; import "./VaultAuthorization.sol"; /** * Implement User Balance interactions, which combine Internal Balance and using the Vault's ERC20 allowance. * * Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later * transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination * when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced * gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users. * * Internal Balance management features batching, which means a single contract call can be used to perform multiple * operations of different kinds, with different senders and recipients, at once. */ abstract contract UserBalance is ReentrancyGuard, AssetTransfersHandler, VaultAuthorization { using Math for uint256; using SafeCast for uint256; using SafeERC20 for IERC20; // Internal Balance for each token, for each account. mapping(address => mapping(IERC20 => uint256)) private _internalTokenBalance; function getInternalBalance(address user, IERC20[] memory tokens) external view override returns (uint256[] memory balances) { balances = new uint256[](tokens.length); for (uint256 i = 0; i < tokens.length; i++) { balances[i] = _getInternalBalance(user, tokens[i]); } } function manageUserBalance(UserBalanceOp[] memory ops) external payable override nonReentrant { // We need to track how much of the received ETH was used and wrapped into WETH to return any excess. uint256 ethWrapped = 0; // Cache for these checks so we only perform them once (if at all). bool checkedCallerIsRelayer = false; bool checkedNotPaused = false; for (uint256 i = 0; i < ops.length; i++) { UserBalanceOpKind kind; IAsset asset; uint256 amount; address sender; address payable recipient; // This destructuring by calling `_validateUserBalanceOp` seems odd, but results in reduced bytecode size. (kind, asset, amount, sender, recipient, checkedCallerIsRelayer) = _validateUserBalanceOp( ops[i], checkedCallerIsRelayer ); if (kind == UserBalanceOpKind.WITHDRAW_INTERNAL) { // Internal Balance withdrawals can always be performed by an authorized account. _withdrawFromInternalBalance(asset, sender, recipient, amount); } else { // All other operations are blocked if the contract is paused. // We cache the result of the pause check and skip it for other operations in this same transaction // (if any). if (!checkedNotPaused) { _ensureNotPaused(); checkedNotPaused = true; } if (kind == UserBalanceOpKind.DEPOSIT_INTERNAL) { _depositToInternalBalance(asset, sender, recipient, amount); // Keep track of all ETH wrapped into WETH as part of a deposit. if (_isETH(asset)) { ethWrapped = ethWrapped.add(amount); } } else { // Transfers don't support ETH. _require(!_isETH(asset), Errors.CANNOT_USE_ETH_SENTINEL); IERC20 token = _asIERC20(asset); if (kind == UserBalanceOpKind.TRANSFER_INTERNAL) { _transferInternalBalance(token, sender, recipient, amount); } else { // TRANSFER_EXTERNAL _transferToExternalBalance(token, sender, recipient, amount); } } } } // Handle any remaining ETH. _handleRemainingEth(ethWrapped); } function _depositToInternalBalance( IAsset asset, address sender, address recipient, uint256 amount ) private { _increaseInternalBalance(recipient, _translateToIERC20(asset), amount); _receiveAsset(asset, amount, sender, false); } function _withdrawFromInternalBalance( IAsset asset, address sender, address payable recipient, uint256 amount ) private { // A partial decrease of Internal Balance is disallowed: `sender` must have the full `amount`. _decreaseInternalBalance(sender, _translateToIERC20(asset), amount, false); _sendAsset(asset, amount, recipient, false); } function _transferInternalBalance( IERC20 token, address sender, address recipient, uint256 amount ) private { // A partial decrease of Internal Balance is disallowed: `sender` must have the full `amount`. _decreaseInternalBalance(sender, token, amount, false); _increaseInternalBalance(recipient, token, amount); } function _transferToExternalBalance( IERC20 token, address sender, address recipient, uint256 amount ) private { if (amount > 0) { token.safeTransferFrom(sender, recipient, amount); emit ExternalBalanceTransfer(token, sender, recipient, amount); } } /** * @dev Increases `account`'s Internal Balance for `token` by `amount`. */ function _increaseInternalBalance( address account, IERC20 token, uint256 amount ) internal override { uint256 currentBalance = _getInternalBalance(account, token); uint256 newBalance = currentBalance.add(amount); _setInternalBalance(account, token, newBalance, amount.toInt256()); } /** * @dev Decreases `account`'s Internal Balance for `token` by `amount`. If `allowPartial` is true, this function * doesn't revert if `account` doesn't have enough balance, and sets it to zero and returns the deducted amount * instead. */ function _decreaseInternalBalance( address account, IERC20 token, uint256 amount, bool allowPartial ) internal override returns (uint256 deducted) { uint256 currentBalance = _getInternalBalance(account, token); _require(allowPartial || (currentBalance >= amount), Errors.INSUFFICIENT_INTERNAL_BALANCE); deducted = Math.min(currentBalance, amount); // By construction, `deducted` is lower or equal to `currentBalance`, so we don't need to use checked // arithmetic. uint256 newBalance = currentBalance - deducted; _setInternalBalance(account, token, newBalance, -(deducted.toInt256())); } /** * @dev Sets `account`'s Internal Balance for `token` to `newBalance`. * * Emits an `InternalBalanceChanged` event. This event includes `delta`, which is the amount the balance increased * (if positive) or decreased (if negative). To avoid reading the current balance in order to compute the delta, * this function relies on the caller providing it directly. */ function _setInternalBalance( address account, IERC20 token, uint256 newBalance, int256 delta ) private { _internalTokenBalance[account][token] = newBalance; emit InternalBalanceChanged(account, token, delta); } /** * @dev Returns `account`'s Internal Balance for `token`. */ function _getInternalBalance(address account, IERC20 token) internal view returns (uint256) { return _internalTokenBalance[account][token]; } /** * @dev Destructures a User Balance operation, validating that the contract caller is allowed to perform it. */ function _validateUserBalanceOp(UserBalanceOp memory op, bool checkedCallerIsRelayer) private view returns ( UserBalanceOpKind, IAsset, uint256, address, address payable, bool ) { // The only argument we need to validate is `sender`, which can only be either the contract caller, or a // relayer approved by `sender`. address sender = op.sender; if (sender != msg.sender) { // We need to check both that the contract caller is a relayer, and that `sender` approved them. // Because the relayer check is global (i.e. independent of `sender`), we cache that result and skip it for // other operations in this same transaction (if any). if (!checkedCallerIsRelayer) { _authenticateCaller(); checkedCallerIsRelayer = true; } _require(_hasApprovedRelayer(sender, msg.sender), Errors.USER_DOESNT_ALLOW_RELAYER); } return (op.kind, op.asset, op.amount, sender, op.recipient, checkedCallerIsRelayer); } }
/contracts/VaultAuthorization.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../lib/helpers/BalancerErrors.sol"; import "../lib/helpers/Authentication.sol"; import "../lib/helpers/TemporarilyPausable.sol"; import "../lib/helpers/BalancerErrors.sol"; import "../lib/helpers/SignaturesValidator.sol"; import "../lib/openzeppelin/ReentrancyGuard.sol"; import "./interfaces/IVault.sol"; import "./interfaces/IAuthorizer.sol"; /** * @dev Manages access control of Vault permissioned functions by relying on the Authorizer and signature validation. * * Additionally handles relayer access and approval. */ abstract contract VaultAuthorization is IVault, ReentrancyGuard, Authentication, SignaturesValidator, TemporarilyPausable { // Ideally, we'd store the type hashes as immutable state variables to avoid computing the hash at runtime, but // unfortunately immutable variables cannot be used in assembly, so we just keep the precomputed hashes instead. // _JOIN_TYPE_HASH = keccak256("JoinPool(bytes calldata,address sender,uint256 nonce,uint256 deadline)"); bytes32 private constant _JOIN_TYPE_HASH = 0x3f7b71252bd19113ff48c19c6e004a9bcfcca320a0d74d58e85877cbd7dcae58; // _EXIT_TYPE_HASH = keccak256("ExitPool(bytes calldata,address sender,uint256 nonce,uint256 deadline)"); bytes32 private constant _EXIT_TYPE_HASH = 0x8bbc57f66ea936902f50a71ce12b92c43f3c5340bb40c27c4e90ab84eeae3353; // _SWAP_TYPE_HASH = keccak256("Swap(bytes calldata,address sender,uint256 nonce,uint256 deadline)"); bytes32 private constant _SWAP_TYPE_HASH = 0xe192dcbc143b1e244ad73b813fd3c097b832ad260a157340b4e5e5beda067abe; // _BATCH_SWAP_TYPE_HASH = keccak256("BatchSwap(bytes calldata,address sender,uint256 nonce,uint256 deadline)"); bytes32 private constant _BATCH_SWAP_TYPE_HASH = 0x9bfc43a4d98313c6766986ffd7c916c7481566d9f224c6819af0a53388aced3a; // _SET_RELAYER_TYPE_HASH = // keccak256("SetRelayerApproval(bytes calldata,address sender,uint256 nonce,uint256 deadline)"); bytes32 private constant _SET_RELAYER_TYPE_HASH = 0xa3f865aa351e51cfeb40f5178d1564bb629fe9030b83caf6361d1baaf5b90b5a; IAuthorizer private _authorizer; mapping(address => mapping(address => bool)) private _approvedRelayers; /** * @dev Reverts unless `user` is the caller, or the caller is approved by the Authorizer to call this function (that * is, it is a relayer for that function), and either: * a) `user` approved the caller as a relayer (via `setRelayerApproval`), or * b) a valid signature from them was appended to the calldata. * * Should only be applied to external functions. */ modifier authenticateFor(address user) { _authenticateFor(user); _; } constructor(IAuthorizer authorizer) // The Vault is a singleton, so it simply uses its own address to disambiguate action identifiers. Authentication(bytes32(uint256(address(this)))) SignaturesValidator("Balancer V2 Vault") { _setAuthorizer(authorizer); } function setAuthorizer(IAuthorizer newAuthorizer) external override nonReentrant authenticate { _setAuthorizer(newAuthorizer); } function _setAuthorizer(IAuthorizer newAuthorizer) private { emit AuthorizerChanged(newAuthorizer); _authorizer = newAuthorizer; } function getAuthorizer() external view override returns (IAuthorizer) { return _authorizer; } function setRelayerApproval( address sender, address relayer, bool approved ) external override nonReentrant whenNotPaused authenticateFor(sender) { _approvedRelayers[sender][relayer] = approved; emit RelayerApprovalChanged(relayer, sender, approved); } function hasApprovedRelayer(address user, address relayer) external view override returns (bool) { return _hasApprovedRelayer(user, relayer); } /** * @dev Reverts unless `user` is the caller, or the caller is approved by the Authorizer to call the entry point * function (that is, it is a relayer for that function) and either: * a) `user` approved the caller as a relayer (via `setRelayerApproval`), or * b) a valid signature from them was appended to the calldata. */ function _authenticateFor(address user) internal { if (msg.sender != user) { // In this context, 'permission to call a function' means 'being a relayer for a function'. _authenticateCaller(); // Being a relayer is not sufficient: `user` must have also approved the caller either via // `setRelayerApproval`, or by providing a signature appended to the calldata. if (!_hasApprovedRelayer(user, msg.sender)) { _validateSignature(user, Errors.USER_DOESNT_ALLOW_RELAYER); } } } /** * @dev Returns true if `user` approved `relayer` to act as a relayer for them. */ function _hasApprovedRelayer(address user, address relayer) internal view returns (bool) { return _approvedRelayers[user][relayer]; } function _canPerform(bytes32 actionId, address user) internal view override returns (bool) { // Access control is delegated to the Authorizer. return _authorizer.canPerform(actionId, user, address(this)); } function _typeHash() internal pure override returns (bytes32 hash) { // This is a simple switch-case statement, trivially written in Solidity by chaining else-if statements, but the // assembly implementation results in much denser bytecode. // solhint-disable-next-line no-inline-assembly assembly { // The function selector is located at the first 4 bytes of calldata. We copy the first full calldata // 256 word, and then perform a logical shift to the right, moving the selector to the least significant // 4 bytes. let selector := shr(224, calldataload(0)) // With the selector in the least significant 4 bytes, we can use 4 byte literals with leading zeros, // resulting in dense bytecode (PUSH4 opcodes). switch selector case 0xb95cac28 { hash := _JOIN_TYPE_HASH } case 0x8bdb3913 { hash := _EXIT_TYPE_HASH } case 0x52bbbe29 { hash := _SWAP_TYPE_HASH } case 0x945bcec9 { hash := _BATCH_SWAP_TYPE_HASH } case 0xfa6e671d { hash := _SET_RELAYER_TYPE_HASH } default { hash := 0x0000000000000000000000000000000000000000000000000000000000000000 } } } }
/contracts/balances/BalanceAllocation.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "../../lib/math/Math.sol"; // This library is used to create a data structure that represents a token's balance for a Pool. 'cash' is how many // tokens the Pool has sitting inside of the Vault. 'managed' is how many tokens were withdrawn from the Vault by the // Pool's Asset Manager. 'total' is the sum of these two, and represents the Pool's total token balance, including // tokens that are *not* inside of the Vault. // // 'cash' is updated whenever tokens enter and exit the Vault, while 'managed' is only updated if the reason tokens are // moving is due to an Asset Manager action. This is reflected in the different methods available: 'increaseCash' // and 'decreaseCash' for swaps and add/remove liquidity events, and 'cashToManaged' and 'managedToCash' for events // transferring funds to and from the Asset Manager. // // The Vault disallows the Pool's 'cash' from becoming negative. In other words, it can never use any tokens that are // not inside the Vault. // // One of the goals of this library is to store the entire token balance in a single storage slot, which is why we use // 112 bit unsigned integers for 'cash' and 'managed'. For consistency, we also disallow any combination of 'cash' and // 'managed' that yields a 'total' that doesn't fit in 112 bits. // // The remaining 32 bits of the slot are used to store the most recent block when the total balance changed. This // can be used to implement price oracles that are resilient to 'sandwich' attacks. // // We could use a Solidity struct to pack these three values together in a single storage slot, but unfortunately // Solidity only allows for structs to live in either storage, calldata or memory. Because a memory struct still takes // up a slot in the stack (to store its memory location), and because the entire balance fits in a single stack slot // (two 112 bit values plus the 32 bit block), using memory is strictly less gas performant. Therefore, we do manual // packing and unpacking. // // Since we cannot define new types, we rely on bytes32 to represent these values instead, as it doesn't have any // associated arithmetic operations and therefore reduces the chance of misuse. library BalanceAllocation { using Math for uint256; // The 'cash' portion of the balance is stored in the least significant 112 bits of a 256 bit word, while the // 'managed' part uses the following 112 bits. The most significant 32 bits are used to store the block /** * @dev Returns the total amount of Pool tokens, including those that are not currently in the Vault ('managed'). */ function total(bytes32 balance) internal pure returns (uint256) { // Since 'cash' and 'managed' are 112 bit values, we don't need checked arithmetic. Additionally, `toBalance` // ensures that 'total' always fits in 112 bits. return cash(balance) + managed(balance); } /** * @dev Returns the amount of Pool tokens currently in the Vault. */ function cash(bytes32 balance) internal pure returns (uint256) { uint256 mask = 2**(112) - 1; return uint256(balance) & mask; } /** * @dev Returns the amount of Pool tokens that are being managed by an Asset Manager. */ function managed(bytes32 balance) internal pure returns (uint256) { uint256 mask = 2**(112) - 1; return uint256(balance >> 112) & mask; } /** * @dev Returns the last block when the total balance changed. */ function lastChangeBlock(bytes32 balance) internal pure returns (uint256) { uint256 mask = 2**(32) - 1; return uint256(balance >> 224) & mask; } /** * @dev Returns the difference in 'managed' between two balances. */ function managedDelta(bytes32 newBalance, bytes32 oldBalance) internal pure returns (int256) { // Because `managed` is a 112 bit value, we can safely perform unchecked arithmetic in 256 bits. return int256(managed(newBalance)) - int256(managed(oldBalance)); } /** * @dev Returns the total balance for each entry in `balances`, as well as the latest block when the total * balance of *any* of them last changed. */ function totalsAndLastChangeBlock(bytes32[] memory balances) internal pure returns ( uint256[] memory results, uint256 lastChangeBlock_ // Avoid shadowing ) { results = new uint256[](balances.length); lastChangeBlock_ = 0; for (uint256 i = 0; i < results.length; i++) { bytes32 balance = balances[i]; results[i] = total(balance); lastChangeBlock_ = Math.max(lastChangeBlock_, lastChangeBlock(balance)); } } /** * @dev Returns true if `balance`'s 'total' balance is zero. Costs less gas than computing 'total' and comparing * with zero. */ function isZero(bytes32 balance) internal pure returns (bool) { // We simply need to check the least significant 224 bytes of the word: the block does not affect this. uint256 mask = 2**(224) - 1; return (uint256(balance) & mask) == 0; } /** * @dev Returns true if `balance`'s 'total' balance is not zero. Costs less gas than computing 'total' and comparing * with zero. */ function isNotZero(bytes32 balance) internal pure returns (bool) { return !isZero(balance); } /** * @dev Packs together `cash` and `managed` amounts with a block to create a balance value. * * For consistency, this also checks that the sum of `cash` and `managed` (`total`) fits in 112 bits. */ function toBalance( uint256 _cash, uint256 _managed, uint256 _blockNumber ) internal pure returns (bytes32) { uint256 _total = _cash + _managed; // Since both 'cash' and 'managed' are positive integers, by checking that their sum ('total') fits in 112 bits // we are also indirectly checking that both 'cash' and 'managed' themselves fit in 112 bits. _require(_total >= _cash && _total < 2**112, Errors.BALANCE_TOTAL_OVERFLOW); // We assume the block fits in 32 bits - this is expected to hold for at least a few decades. return _pack(_cash, _managed, _blockNumber); } /** * @dev Increases a Pool's 'cash' (and therefore its 'total'). Called when Pool tokens are sent to the Vault (except * for Asset Manager deposits). * * Updates the last total balance change block, even if `amount` is zero. */ function increaseCash(bytes32 balance, uint256 amount) internal view returns (bytes32) { uint256 newCash = cash(balance).add(amount); uint256 currentManaged = managed(balance); uint256 newLastChangeBlock = block.number; return toBalance(newCash, currentManaged, newLastChangeBlock); } /** * @dev Decreases a Pool's 'cash' (and therefore its 'total'). Called when Pool tokens are sent from the Vault * (except for Asset Manager withdrawals). * * Updates the last total balance change block, even if `amount` is zero. */ function decreaseCash(bytes32 balance, uint256 amount) internal view returns (bytes32) { uint256 newCash = cash(balance).sub(amount); uint256 currentManaged = managed(balance); uint256 newLastChangeBlock = block.number; return toBalance(newCash, currentManaged, newLastChangeBlock); } /** * @dev Moves 'cash' into 'managed', leaving 'total' unchanged. Called when an Asset Manager withdraws Pool tokens * from the Vault. */ function cashToManaged(bytes32 balance, uint256 amount) internal pure returns (bytes32) { uint256 newCash = cash(balance).sub(amount); uint256 newManaged = managed(balance).add(amount); uint256 currentLastChangeBlock = lastChangeBlock(balance); return toBalance(newCash, newManaged, currentLastChangeBlock); } /** * @dev Moves 'managed' into 'cash', leaving 'total' unchanged. Called when an Asset Manager deposits Pool tokens * into the Vault. */ function managedToCash(bytes32 balance, uint256 amount) internal pure returns (bytes32) { uint256 newCash = cash(balance).add(amount); uint256 newManaged = managed(balance).sub(amount); uint256 currentLastChangeBlock = lastChangeBlock(balance); return toBalance(newCash, newManaged, currentLastChangeBlock); } /** * @dev Sets 'managed' balance to an arbitrary value, changing 'total'. Called when the Asset Manager reports * profits or losses. It's the Manager's responsibility to provide a meaningful value. * * Updates the last total balance change block, even if `newManaged` is equal to the current 'managed' value. */ function setManaged(bytes32 balance, uint256 newManaged) internal view returns (bytes32) { uint256 currentCash = cash(balance); uint256 newLastChangeBlock = block.number; return toBalance(currentCash, newManaged, newLastChangeBlock); } // Alternative mode for Pools with the Two Token specialization setting // Instead of storing cash and external for each 'token in' a single storage slot, Two Token Pools store the cash // for both tokens in the same slot, and the managed for both in another one. This reduces the gas cost for swaps, // because the only slot that needs to be updated is the one with the cash. However, it also means that managing // balances is more cumbersome, as both tokens need to be read/written at the same time. // // The field with both cash balances packed is called sharedCash, and the one with external amounts is called // sharedManaged. These two are collectively called the 'shared' balance fields. In both of these, the portion // that corresponds to token A is stored in the least significant 112 bits of a 256 bit word, while token B's part // uses the next least significant 112 bits. // // Because only cash is written to during a swap, we store the last total balance change block with the // packed cash fields. Typically Pools have a distinct block per token: in the case of Two Token Pools they // are the same. /** * @dev Extracts the part of the balance that corresponds to token A. This function can be used to decode both * shared cash and managed balances. */ function _decodeBalanceA(bytes32 sharedBalance) private pure returns (uint256) { uint256 mask = 2**(112) - 1; return uint256(sharedBalance) & mask; } /** * @dev Extracts the part of the balance that corresponds to token B. This function can be used to decode both * shared cash and managed balances. */ function _decodeBalanceB(bytes32 sharedBalance) private pure returns (uint256) { uint256 mask = 2**(112) - 1; return uint256(sharedBalance >> 112) & mask; } // To decode the last balance change block, we can simply use the `blockNumber` function. /** * @dev Unpacks the shared token A and token B cash and managed balances into the balance for token A. */ function fromSharedToBalanceA(bytes32 sharedCash, bytes32 sharedManaged) internal pure returns (bytes32) { // Note that we extract the block from the sharedCash field, which is the one that is updated by swaps. // Both token A and token B use the same block return toBalance(_decodeBalanceA(sharedCash), _decodeBalanceA(sharedManaged), lastChangeBlock(sharedCash)); } /** * @dev Unpacks the shared token A and token B cash and managed balances into the balance for token B. */ function fromSharedToBalanceB(bytes32 sharedCash, bytes32 sharedManaged) internal pure returns (bytes32) { // Note that we extract the block from the sharedCash field, which is the one that is updated by swaps. // Both token A and token B use the same block return toBalance(_decodeBalanceB(sharedCash), _decodeBalanceB(sharedManaged), lastChangeBlock(sharedCash)); } /** * @dev Returns the sharedCash shared field, given the current balances for token A and token B. */ function toSharedCash(bytes32 tokenABalance, bytes32 tokenBBalance) internal pure returns (bytes32) { // Both balances are assigned the same block Since it is possible a single one of them has changed (for // example, in an Asset Manager update), we keep the latest (largest) one. uint32 newLastChangeBlock = uint32(Math.max(lastChangeBlock(tokenABalance), lastChangeBlock(tokenBBalance))); return _pack(cash(tokenABalance), cash(tokenBBalance), newLastChangeBlock); } /** * @dev Returns the sharedManaged shared field, given the current balances for token A and token B. */ function toSharedManaged(bytes32 tokenABalance, bytes32 tokenBBalance) internal pure returns (bytes32) { // We don't bother storing a last change block, as it is read from the shared cash field. return _pack(managed(tokenABalance), managed(tokenBBalance), 0); } // Shared functions /** * @dev Packs together two uint112 and one uint32 into a bytes32 */ function _pack( uint256 _leastSignificant, uint256 _midSignificant, uint256 _mostSignificant ) private pure returns (bytes32) { return bytes32((_mostSignificant << 224) + (_midSignificant << 112) + _leastSignificant); } }
/contracts/balances/GeneralPoolsBalance.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "../../lib/helpers/BalancerErrors.sol"; import "../../lib/openzeppelin/EnumerableMap.sol"; import "../../lib/openzeppelin/IERC20.sol"; import "./BalanceAllocation.sol"; abstract contract GeneralPoolsBalance { using BalanceAllocation for bytes32; using EnumerableMap for EnumerableMap.IERC20ToBytes32Map; // Data for Pools with the General specialization setting // // These Pools use the IGeneralPool interface, which means the Vault must query the balance for *all* of their // tokens in every swap. If we kept a mapping of token to balance plus a set (array) of tokens, it'd be very gas // intensive to read all token addresses just to then do a lookup on the balance mapping. // // Instead, we use our customized EnumerableMap, which lets us read the N balances in N+1 storage accesses (one for // each token in the Pool), access the index of any 'token in' a single read (required for the IGeneralPool call), // and update an entry's value given its index. // Map of token -> balance pairs for each Pool with this specialization. Many functions rely on storage pointers to // a Pool's EnumerableMap to save gas when computing storage slots. mapping(bytes32 => EnumerableMap.IERC20ToBytes32Map) internal _generalPoolsBalances; /** * @dev Registers a list of tokens in a General Pool. * * This function assumes `poolId` exists and corresponds to the General specialization setting. * * Requirements: * * - `tokens` must not be registered in the Pool * - `tokens` must not contain duplicates */ function _registerGeneralPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; for (uint256 i = 0; i < tokens.length; ++i) { // EnumerableMaps require an explicit initial value when creating a key-value pair: we use zero, the same // value that is found in uninitialized storage, which corresponds to an empty balance. bool added = poolBalances.set(tokens[i], 0); _require(added, Errors.TOKEN_ALREADY_REGISTERED); } } /** * @dev Deregisters a list of tokens in a General Pool. * * This function assumes `poolId` exists and corresponds to the General specialization setting. * * Requirements: * * - `tokens` must be registered in the Pool * - `tokens` must have zero balance in the Vault * - `tokens` must not contain duplicates */ function _deregisterGeneralPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; for (uint256 i = 0; i < tokens.length; ++i) { IERC20 token = tokens[i]; bytes32 currentBalance = _getGeneralPoolBalance(poolBalances, token); _require(currentBalance.isZero(), Errors.NONZERO_TOKEN_BALANCE); // We don't need to check remove's return value, since _getGeneralPoolBalance already checks that the token // was registered. poolBalances.remove(token); } } /** * @dev Sets the balances of a General Pool's tokens to `balances`. * * WARNING: this assumes `balances` has the same length and order as the Pool's tokens. */ function _setGeneralPoolBalances(bytes32 poolId, bytes32[] memory balances) internal { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; for (uint256 i = 0; i < balances.length; ++i) { // Since we assume all balances are properly ordered, we can simply use `unchecked_setAt` to avoid one less // storage read per token. poolBalances.unchecked_setAt(i, balances[i]); } } /** * @dev Transforms `amount` of `token`'s balance in a General Pool from cash into managed. * * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is * registered for that Pool. */ function _generalPoolCashToManaged( bytes32 poolId, IERC20 token, uint256 amount ) internal { _updateGeneralPoolBalance(poolId, token, BalanceAllocation.cashToManaged, amount); } /** * @dev Transforms `amount` of `token`'s balance in a General Pool from managed into cash. * * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is * registered for that Pool. */ function _generalPoolManagedToCash( bytes32 poolId, IERC20 token, uint256 amount ) internal { _updateGeneralPoolBalance(poolId, token, BalanceAllocation.managedToCash, amount); } /** * @dev Sets `token`'s managed balance in a General Pool to `amount`. * * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is * registered for that Pool. * * Returns the managed balance delta as a result of this call. */ function _setGeneralPoolManagedBalance( bytes32 poolId, IERC20 token, uint256 amount ) internal returns (int256) { return _updateGeneralPoolBalance(poolId, token, BalanceAllocation.setManaged, amount); } /** * @dev Sets `token`'s balance in a General Pool to the result of the `mutation` function when called with the * current balance and `amount`. * * This function assumes `poolId` exists, corresponds to the General specialization setting, and that `token` is * registered for that Pool. * * Returns the managed balance delta as a result of this call. */ function _updateGeneralPoolBalance( bytes32 poolId, IERC20 token, function(bytes32, uint256) returns (bytes32) mutation, uint256 amount ) private returns (int256) { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; bytes32 currentBalance = _getGeneralPoolBalance(poolBalances, token); bytes32 newBalance = mutation(currentBalance, amount); poolBalances.set(token, newBalance); return newBalance.managedDelta(currentBalance); } /** * @dev Returns an array with all the tokens and balances in a General Pool. The order may change when tokens are * registered or deregistered. * * This function assumes `poolId` exists and corresponds to the General specialization setting. */ function _getGeneralPoolTokens(bytes32 poolId) internal view returns (IERC20[] memory tokens, bytes32[] memory balances) { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; tokens = new IERC20[](poolBalances.length()); balances = new bytes32[](tokens.length); for (uint256 i = 0; i < tokens.length; ++i) { // Because the iteration is bounded by `tokens.length`, which matches the EnumerableMap's length, we can use // `unchecked_at` as we know `i` is a valid token index, saving storage reads. (tokens[i], balances[i]) = poolBalances.unchecked_at(i); } } /** * @dev Returns the balance of a token in a General Pool. * * This function assumes `poolId` exists and corresponds to the General specialization setting. * * Requirements: * * - `token` must be registered in the Pool */ function _getGeneralPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; return _getGeneralPoolBalance(poolBalances, token); } /** * @dev Same as `_getGeneralPoolBalance` but using a Pool's storage pointer, which saves gas in repeated reads and * writes. */ function _getGeneralPoolBalance(EnumerableMap.IERC20ToBytes32Map storage poolBalances, IERC20 token) private view returns (bytes32) { return poolBalances.get(token, Errors.TOKEN_NOT_REGISTERED); } /** * @dev Returns true if `token` is registered in a General Pool. * * This function assumes `poolId` exists and corresponds to the General specialization setting. */ function _isGeneralPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) { EnumerableMap.IERC20ToBytes32Map storage poolBalances = _generalPoolsBalances[poolId]; return poolBalances.contains(token); } }
/contracts/balances/MinimalSwapInfoPoolsBalance.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../../lib/helpers/BalancerErrors.sol"; import "../../lib/openzeppelin/EnumerableSet.sol"; import "../../lib/openzeppelin/IERC20.sol"; import "./BalanceAllocation.sol"; import "../PoolRegistry.sol"; abstract contract MinimalSwapInfoPoolsBalance is PoolRegistry { using BalanceAllocation for bytes32; using EnumerableSet for EnumerableSet.AddressSet; // Data for Pools with the Minimal Swap Info specialization setting // // These Pools use the IMinimalSwapInfoPool interface, and so the Vault must read the balance of the two tokens // in the swap. The best solution is to use a mapping from token to balance, which lets us read or write any token's // balance in a single storage access. // // We also keep a set of registered tokens. Because tokens with non-zero balance are by definition registered, in // some balance getters we skip checking for token registration if a non-zero balance is found, saving gas by // performing a single read instead of two. mapping(bytes32 => mapping(IERC20 => bytes32)) internal _minimalSwapInfoPoolsBalances; mapping(bytes32 => EnumerableSet.AddressSet) internal _minimalSwapInfoPoolsTokens; /** * @dev Registers a list of tokens in a Minimal Swap Info Pool. * * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting. * * Requirements: * * - `tokens` must not be registered in the Pool * - `tokens` must not contain duplicates */ function _registerMinimalSwapInfoPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal { EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId]; for (uint256 i = 0; i < tokens.length; ++i) { bool added = poolTokens.add(address(tokens[i])); _require(added, Errors.TOKEN_ALREADY_REGISTERED); // Note that we don't initialize the balance mapping: the default value of zero corresponds to an empty // balance. } } /** * @dev Deregisters a list of tokens in a Minimal Swap Info Pool. * * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting. * * Requirements: * * - `tokens` must be registered in the Pool * - `tokens` must have zero balance in the Vault * - `tokens` must not contain duplicates */ function _deregisterMinimalSwapInfoPoolTokens(bytes32 poolId, IERC20[] memory tokens) internal { EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId]; for (uint256 i = 0; i < tokens.length; ++i) { IERC20 token = tokens[i]; _require(_minimalSwapInfoPoolsBalances[poolId][token].isZero(), Errors.NONZERO_TOKEN_BALANCE); // For consistency with other Pool specialization settings, we explicitly reset the balance (which may have // a non-zero last change block). delete _minimalSwapInfoPoolsBalances[poolId][token]; bool removed = poolTokens.remove(address(token)); _require(removed, Errors.TOKEN_NOT_REGISTERED); } } /** * @dev Sets the balances of a Minimal Swap Info Pool's tokens to `balances`. * * WARNING: this assumes `balances` has the same length and order as the Pool's tokens. */ function _setMinimalSwapInfoPoolBalances( bytes32 poolId, IERC20[] memory tokens, bytes32[] memory balances ) internal { for (uint256 i = 0; i < tokens.length; ++i) { _minimalSwapInfoPoolsBalances[poolId][tokens[i]] = balances[i]; } } /** * @dev Transforms `amount` of `token`'s balance in a Minimal Swap Info Pool from cash into managed. * * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that * `token` is registered for that Pool. */ function _minimalSwapInfoPoolCashToManaged( bytes32 poolId, IERC20 token, uint256 amount ) internal { _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.cashToManaged, amount); } /** * @dev Transforms `amount` of `token`'s balance in a Minimal Swap Info Pool from managed into cash. * * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that * `token` is registered for that Pool. */ function _minimalSwapInfoPoolManagedToCash( bytes32 poolId, IERC20 token, uint256 amount ) internal { _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.managedToCash, amount); } /** * @dev Sets `token`'s managed balance in a Minimal Swap Info Pool to `amount`. * * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that * `token` is registered for that Pool. * * Returns the managed balance delta as a result of this call. */ function _setMinimalSwapInfoPoolManagedBalance( bytes32 poolId, IERC20 token, uint256 amount ) internal returns (int256) { return _updateMinimalSwapInfoPoolBalance(poolId, token, BalanceAllocation.setManaged, amount); } /** * @dev Sets `token`'s balance in a Minimal Swap Info Pool to the result of the `mutation` function when called with * the current balance and `amount`. * * This function assumes `poolId` exists, corresponds to the Minimal Swap Info specialization setting, and that * `token` is registered for that Pool. * * Returns the managed balance delta as a result of this call. */ function _updateMinimalSwapInfoPoolBalance( bytes32 poolId, IERC20 token, function(bytes32, uint256) returns (bytes32) mutation, uint256 amount ) internal returns (int256) { bytes32 currentBalance = _getMinimalSwapInfoPoolBalance(poolId, token); bytes32 newBalance = mutation(currentBalance, amount); _minimalSwapInfoPoolsBalances[poolId][token] = newBalance; return newBalance.managedDelta(currentBalance); } /** * @dev Returns an array with all the tokens and balances in a Minimal Swap Info Pool. The order may change when * tokens are registered or deregistered. * * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting. */ function _getMinimalSwapInfoPoolTokens(bytes32 poolId) internal view returns (IERC20[] memory tokens, bytes32[] memory balances) { EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId]; tokens = new IERC20[](poolTokens.length()); balances = new bytes32[](tokens.length); for (uint256 i = 0; i < tokens.length; ++i) { // Because the iteration is bounded by `tokens.length`, which matches the EnumerableSet's length, we can use // `unchecked_at` as we know `i` is a valid token index, saving storage reads. IERC20 token = IERC20(poolTokens.unchecked_at(i)); tokens[i] = token; balances[i] = _minimalSwapInfoPoolsBalances[poolId][token]; } } /** * @dev Returns the balance of a token in a Minimal Swap Info Pool. * * Requirements: * * - `poolId` must be a Minimal Swap Info Pool * - `token` must be registered in the Pool */ function _getMinimalSwapInfoPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) { bytes32 balance = _minimalSwapInfoPoolsBalances[poolId][token]; // A non-zero balance guarantees that the token is registered. If zero, we manually check if the token is // registered in the Pool. Token registration implies that the Pool is registered as well, which lets us save // gas by not performing the check. bool tokenRegistered = balance.isNotZero() || _minimalSwapInfoPoolsTokens[poolId].contains(address(token)); if (!tokenRegistered) { // The token might not be registered because the Pool itself is not registered. We check this to provide a // more accurate revert reason. _ensureRegisteredPool(poolId); _revert(Errors.TOKEN_NOT_REGISTERED); } return balance; } /** * @dev Returns true if `token` is registered in a Minimal Swap Info Pool. * * This function assumes `poolId` exists and corresponds to the Minimal Swap Info specialization setting. */ function _isMinimalSwapInfoPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) { EnumerableSet.AddressSet storage poolTokens = _minimalSwapInfoPoolsTokens[poolId]; return poolTokens.contains(address(token)); } }
/contracts/balances/TwoTokenPoolsBalance.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../../lib/helpers/BalancerErrors.sol"; import "../../lib/openzeppelin/IERC20.sol"; import "./BalanceAllocation.sol"; import "../PoolRegistry.sol"; abstract contract TwoTokenPoolsBalance is PoolRegistry { using BalanceAllocation for bytes32; // Data for Pools with the Two Token specialization setting // // These are similar to the Minimal Swap Info Pool case (because the Pool only has two tokens, and therefore there // are only two balances to read), but there's a key difference in how data is stored. Keeping a set makes little // sense, as it will only ever hold two tokens, so we can just store those two directly. // // The gas savings associated with using these Pools come from how token balances are stored: cash amounts for token // A and token B are packed together, as are managed amounts. Because only cash changes in a swap, there's no need // to write to this second storage slot. A single last change block number for both tokens is stored with the packed // cash fields. struct TwoTokenPoolBalances { bytes32 sharedCash; bytes32 sharedManaged; } // We could just keep a mapping from Pool ID to TwoTokenSharedBalances, but there's an issue: we wouldn't know to // which tokens those balances correspond. This would mean having to also check which are registered with the Pool. // // What we do instead to save those storage reads is keep a nested mapping from the token pair hash to the balances // struct. The Pool only has two tokens, so only a single entry of this mapping is set (the one that corresponds to // that pair's hash). // // This has the trade-off of making Vault code that interacts with these Pools cumbersome: both balances must be // accessed at the same time by using both token addresses, and some logic is needed to determine how the pair hash // is computed. We do this by sorting the tokens, calling the token with the lowest numerical address value token A, // and the other one token B. In functions where the token arguments could be either A or B, we use X and Y instead. // // If users query a token pair containing an unregistered token, the Pool will generate a hash for a mapping entry // that was not set, and return zero balances. Non-zero balances are only possible if both tokens in the pair // are registered with the Pool, which means we don't have to check the TwoTokenPoolTokens struct, and can save // storage reads. struct TwoTokenPoolTokens { IERC20 tokenA; IERC20 tokenB; mapping(bytes32 => TwoTokenPoolBalances) balances; } mapping(bytes32 => TwoTokenPoolTokens) private _twoTokenPoolTokens; /** * @dev Registers tokens in a Two Token Pool. * * This function assumes `poolId` exists and corresponds to the Two Token specialization setting. * * Requirements: * * - `tokenX` and `tokenY` must not be the same * - The tokens must be ordered: tokenX < tokenY */ function _registerTwoTokenPoolTokens( bytes32 poolId, IERC20 tokenX, IERC20 tokenY ) internal { // Not technically true since we didn't register yet, but this is consistent with the error messages of other // specialization settings. _require(tokenX != tokenY, Errors.TOKEN_ALREADY_REGISTERED); _require(tokenX < tokenY, Errors.UNSORTED_TOKENS); // A Two Token Pool with no registered tokens is identified by having zero addresses for tokens A and B. TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId]; _require(poolTokens.tokenA == IERC20(0) && poolTokens.tokenB == IERC20(0), Errors.TOKENS_ALREADY_SET); // Since tokenX < tokenY, tokenX is A and tokenY is B poolTokens.tokenA = tokenX; poolTokens.tokenB = tokenY; // Note that we don't initialize the balance mapping: the default value of zero corresponds to an empty // balance. } /** * @dev Deregisters tokens in a Two Token Pool. * * This function assumes `poolId` exists and corresponds to the Two Token specialization setting. * * Requirements: * * - `tokenX` and `tokenY` must be registered in the Pool * - both tokens must have zero balance in the Vault */ function _deregisterTwoTokenPoolTokens( bytes32 poolId, IERC20 tokenX, IERC20 tokenY ) internal { ( bytes32 balanceA, bytes32 balanceB, TwoTokenPoolBalances storage poolBalances ) = _getTwoTokenPoolSharedBalances(poolId, tokenX, tokenY); _require(balanceA.isZero() && balanceB.isZero(), Errors.NONZERO_TOKEN_BALANCE); delete _twoTokenPoolTokens[poolId]; // For consistency with other Pool specialization settings, we explicitly reset the packed cash field (which may // have a non-zero last change block). delete poolBalances.sharedCash; } /** * @dev Sets the cash balances of a Two Token Pool's tokens. * * WARNING: this assumes `tokenA` and `tokenB` are the Pool's two registered tokens, and are in the correct order. */ function _setTwoTokenPoolCashBalances( bytes32 poolId, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB ) internal { bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB); TwoTokenPoolBalances storage poolBalances = _twoTokenPoolTokens[poolId].balances[pairHash]; poolBalances.sharedCash = BalanceAllocation.toSharedCash(balanceA, balanceB); } /** * @dev Transforms `amount` of `token`'s balance in a Two Token Pool from cash into managed. * * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is * registered for that Pool. */ function _twoTokenPoolCashToManaged( bytes32 poolId, IERC20 token, uint256 amount ) internal { _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.cashToManaged, amount); } /** * @dev Transforms `amount` of `token`'s balance in a Two Token Pool from managed into cash. * * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is * registered for that Pool. */ function _twoTokenPoolManagedToCash( bytes32 poolId, IERC20 token, uint256 amount ) internal { _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.managedToCash, amount); } /** * @dev Sets `token`'s managed balance in a Two Token Pool to `amount`. * * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is * registered for that Pool. * * Returns the managed balance delta as a result of this call. */ function _setTwoTokenPoolManagedBalance( bytes32 poolId, IERC20 token, uint256 amount ) internal returns (int256) { return _updateTwoTokenPoolSharedBalance(poolId, token, BalanceAllocation.setManaged, amount); } /** * @dev Sets `token`'s balance in a Two Token Pool to the result of the `mutation` function when called with * the current balance and `amount`. * * This function assumes `poolId` exists, corresponds to the Two Token specialization setting, and that `token` is * registered for that Pool. * * Returns the managed balance delta as a result of this call. */ function _updateTwoTokenPoolSharedBalance( bytes32 poolId, IERC20 token, function(bytes32, uint256) returns (bytes32) mutation, uint256 amount ) private returns (int256) { ( TwoTokenPoolBalances storage balances, IERC20 tokenA, bytes32 balanceA, , bytes32 balanceB ) = _getTwoTokenPoolBalances(poolId); int256 delta; if (token == tokenA) { bytes32 newBalance = mutation(balanceA, amount); delta = newBalance.managedDelta(balanceA); balanceA = newBalance; } else { // token == tokenB bytes32 newBalance = mutation(balanceB, amount); delta = newBalance.managedDelta(balanceB); balanceB = newBalance; } balances.sharedCash = BalanceAllocation.toSharedCash(balanceA, balanceB); balances.sharedManaged = BalanceAllocation.toSharedManaged(balanceA, balanceB); return delta; } /* * @dev Returns an array with all the tokens and balances in a Two Token Pool. The order may change when * tokens are registered or deregistered. * * This function assumes `poolId` exists and corresponds to the Two Token specialization setting. */ function _getTwoTokenPoolTokens(bytes32 poolId) internal view returns (IERC20[] memory tokens, bytes32[] memory balances) { (, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB) = _getTwoTokenPoolBalances(poolId); // Both tokens will either be zero (if unregistered) or non-zero (if registered), but we keep the full check for // clarity. if (tokenA == IERC20(0) || tokenB == IERC20(0)) { return (new IERC20[](0), new bytes32[](0)); } // Note that functions relying on this getter expect tokens to be properly ordered, so we use the (A, B) // ordering. tokens = new IERC20[](2); tokens[0] = tokenA; tokens[1] = tokenB; balances = new bytes32[](2); balances[0] = balanceA; balances[1] = balanceB; } /** * @dev Same as `_getTwoTokenPoolTokens`, except it returns the two tokens and balances directly instead of using * an array, as well as a storage pointer to the `TwoTokenPoolBalances` struct, which can be used to update it * without having to recompute the pair hash and storage slot. */ function _getTwoTokenPoolBalances(bytes32 poolId) private view returns ( TwoTokenPoolBalances storage poolBalances, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB ) { TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId]; tokenA = poolTokens.tokenA; tokenB = poolTokens.tokenB; bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB); poolBalances = poolTokens.balances[pairHash]; bytes32 sharedCash = poolBalances.sharedCash; bytes32 sharedManaged = poolBalances.sharedManaged; balanceA = BalanceAllocation.fromSharedToBalanceA(sharedCash, sharedManaged); balanceB = BalanceAllocation.fromSharedToBalanceB(sharedCash, sharedManaged); } /** * @dev Returns the balance of a token in a Two Token Pool. * * This function assumes `poolId` exists and corresponds to the General specialization setting. * * This function is convenient but not particularly gas efficient, and should be avoided during gas-sensitive * operations, such as swaps. For those, _getTwoTokenPoolSharedBalances provides a more flexible interface. * * Requirements: * * - `token` must be registered in the Pool */ function _getTwoTokenPoolBalance(bytes32 poolId, IERC20 token) internal view returns (bytes32) { // We can't just read the balance of token, because we need to know the full pair in order to compute the pair // hash and access the balance mapping. We therefore rely on `_getTwoTokenPoolBalances`. (, IERC20 tokenA, bytes32 balanceA, IERC20 tokenB, bytes32 balanceB) = _getTwoTokenPoolBalances(poolId); if (token == tokenA) { return balanceA; } else if (token == tokenB) { return balanceB; } else { _revert(Errors.TOKEN_NOT_REGISTERED); } } /** * @dev Returns the balance of the two tokens in a Two Token Pool. * * The returned balances are those of token A and token B, where token A is the lowest of token X and token Y, and * token B the other. * * This function also returns a storage pointer to the TwoTokenPoolBalances struct associated with the token pair, * which can be used to update it without having to recompute the pair hash and storage slot. * * Requirements: * * - `poolId` must be a Minimal Swap Info Pool * - `tokenX` and `tokenY` must be registered in the Pool */ function _getTwoTokenPoolSharedBalances( bytes32 poolId, IERC20 tokenX, IERC20 tokenY ) internal view returns ( bytes32 balanceA, bytes32 balanceB, TwoTokenPoolBalances storage poolBalances ) { (IERC20 tokenA, IERC20 tokenB) = _sortTwoTokens(tokenX, tokenY); bytes32 pairHash = _getTwoTokenPairHash(tokenA, tokenB); poolBalances = _twoTokenPoolTokens[poolId].balances[pairHash]; // Because we're reading balances using the pair hash, if either token X or token Y is not registered then // *both* balance entries will be zero. bytes32 sharedCash = poolBalances.sharedCash; bytes32 sharedManaged = poolBalances.sharedManaged; // A non-zero balance guarantees that both tokens are registered. If zero, we manually check whether each // token is registered in the Pool. Token registration implies that the Pool is registered as well, which // lets us save gas by not performing the check. bool tokensRegistered = sharedCash.isNotZero() || sharedManaged.isNotZero() || (_isTwoTokenPoolTokenRegistered(poolId, tokenA) && _isTwoTokenPoolTokenRegistered(poolId, tokenB)); if (!tokensRegistered) { // The tokens might not be registered because the Pool itself is not registered. We check this to provide a // more accurate revert reason. _ensureRegisteredPool(poolId); _revert(Errors.TOKEN_NOT_REGISTERED); } balanceA = BalanceAllocation.fromSharedToBalanceA(sharedCash, sharedManaged); balanceB = BalanceAllocation.fromSharedToBalanceB(sharedCash, sharedManaged); } /** * @dev Returns true if `token` is registered in a Two Token Pool. * * This function assumes `poolId` exists and corresponds to the Two Token specialization setting. */ function _isTwoTokenPoolTokenRegistered(bytes32 poolId, IERC20 token) internal view returns (bool) { TwoTokenPoolTokens storage poolTokens = _twoTokenPoolTokens[poolId]; // The zero address can never be a registered token. return (token == poolTokens.tokenA || token == poolTokens.tokenB) && token != IERC20(0); } /** * @dev Returns the hash associated with a given token pair. */ function _getTwoTokenPairHash(IERC20 tokenA, IERC20 tokenB) private pure returns (bytes32) { return keccak256(abi.encodePacked(tokenA, tokenB)); } /** * @dev Sorts two tokens in ascending order, returning them as a (tokenA, tokenB) tuple. */ function _sortTwoTokens(IERC20 tokenX, IERC20 tokenY) private pure returns (IERC20, IERC20) { return tokenX < tokenY ? (tokenX, tokenY) : (tokenY, tokenX); } }
/contracts/interfaces/IAsset.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; /** * @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 }
/contracts/interfaces/IAuthorizer.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; 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); }
/contracts/interfaces/IBasePool.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "./IVault.sol"; import "./IPoolSwapStructs.sol"; /** * @dev Interface for adding and removing liquidity that all Pool contracts should implement. Note that this is not * the complete Pool contract interface, as it is missing the swap hooks. Pool contracts should also inherit from * either IGeneralPool or IMinimalSwapInfoPool */ interface IBasePool is IPoolSwapStructs { /** * @dev Called by the Vault when a user calls `IVault.joinPool` to add liquidity to this Pool. Returns how many of * each registered token the user should provide, as well as the amount of protocol fees the Pool owes to the Vault. * The Vault will then take tokens from `sender` and add them to the Pool's balances, as well as collect * the reported amount in protocol fees, which the pool should calculate based on `protocolSwapFeePercentage`. * * Protocol fees are reported and charged on join events so that the Pool is free of debt whenever new users join. * * `sender` is the account performing the join (from which tokens will be withdrawn), and `recipient` is the account * designated to receive any benefits (typically pool shares). `currentBalances` contains the total balances * for each token the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return. * * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total * balance. * * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of * join (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.) * * Contracts implementing this function should check that the caller is indeed the Vault before performing any * state-changing operations, such as minting pool shares. */ function onJoinPool( bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData ) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts); /** * @dev Called by the Vault when a user calls `IVault.exitPool` to remove liquidity from this Pool. Returns how many * tokens the Vault should deduct from the Pool's balances, as well as the amount of protocol fees the Pool owes * to the Vault. The Vault will then take tokens from the Pool's balances and send them to `recipient`, * as well as collect the reported amount in protocol fees, which the Pool should calculate based on * `protocolSwapFeePercentage`. * * Protocol fees are charged on exit events to guarantee that users exiting the Pool have paid their share. * * `sender` is the account performing the exit (typically the pool shareholder), and `recipient` is the account * to which the Vault will send the proceeds. `currentBalances` contains the total token balances for each token * the Pool registered in the Vault, in the same order that `IVault.getPoolTokens` would return. * * `lastChangeBlock` is the last block in which *any* of the Pool's registered tokens last changed its total * balance. * * `userData` contains any pool-specific instructions needed to perform the calculations, such as the type of * exit (e.g., proportional given an amount of pool shares, single-asset, multi-asset, etc.) * * Contracts implementing this function should check that the caller is indeed the Vault before performing any * state-changing operations, such as burning pool shares. */ function onExitPool( bytes32 poolId, address sender, address recipient, uint256[] memory balances, uint256 lastChangeBlock, uint256 protocolSwapFeePercentage, bytes memory userData ) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts); }
/contracts/interfaces/IFlashLoanRecipient.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; // Inspired by Aave Protocol's IFlashLoanReceiver. import "../../lib/openzeppelin/IERC20.sol"; 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; }
/contracts/interfaces/IGeneralPool.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "./IBasePool.sol"; /** * @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); }
/contracts/interfaces/IMinimalSwapInfoPool.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "./IBasePool.sol"; /** * @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); }
/contracts/interfaces/IPoolSwapStructs.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; pragma experimental ABIEncoderV2; import "../../lib/openzeppelin/IERC20.sol"; import "./IVault.sol"; 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; } }
/contracts/interfaces/IVault.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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; import "../../lib/openzeppelin/IERC20.sol"; import "./IWETH.sol"; import "./IAsset.sol"; import "./IAuthorizer.sol"; import "./IFlashLoanRecipient.sol"; import "../ProtocolFeesCollector.sol"; import "../../lib/helpers/ISignaturesValidator.sol"; import "../../lib/helpers/ITemporarilyPausable.sol"; pragma solidity ^0.7.0; /** * @dev Full external interface for the Vault core contract - no external or public methods exist in the contract that * don't override one of these declarations. */ interface IVault is ISignaturesValidator, ITemporarilyPausable { // Generalities about the Vault: // // - Whenever documentation refers to 'tokens', it strictly refers to ERC20-compliant token contracts. Tokens are // transferred out of the Vault by calling the `IERC20.transfer` function, and transferred in by calling // `IERC20.transferFrom`. In these cases, the sender must have previously allowed the Vault to use their tokens by // calling `IERC20.approve`. The only deviation from the ERC20 standard that is supported is functions not returning // a boolean value: in these scenarios, a non-reverting call is assumed to be successful. // // - All non-view functions in the Vault are non-reentrant: calling them while another one is mid-execution (e.g. // while execution control is transferred to a token contract during a swap) will result in a revert. View // functions can be called in a re-reentrant way, but doing so might cause them to return inconsistent results. // Contracts calling view functions in the Vault must make sure the Vault has not already been entered. // // - View functions revert if referring to either unregistered Pools, or unregistered tokens for registered Pools. // Authorizer // // Some system actions are permissioned, like setting and collecting protocol fees. This permissioning system exists // outside of the Vault in the Authorizer contract: the Vault simply calls the Authorizer to check if the caller // can perform a given action. /** * @dev Returns the Vault's Authorizer. */ function getAuthorizer() external view returns (IAuthorizer); /** * @dev Sets a new Authorizer for the Vault. The caller must be allowed by the current Authorizer to do this. * * Emits an `AuthorizerChanged` event. */ function setAuthorizer(IAuthorizer newAuthorizer) external; /** * @dev Emitted when a new authorizer is set by `setAuthorizer`. */ event AuthorizerChanged(IAuthorizer indexed newAuthorizer); // Relayers // // Additionally, it is possible for an account to perform certain actions on behalf of another one, using their // Vault ERC20 allowance and Internal Balance. These accounts are said to be 'relayers' for these Vault functions, // and are expected to be smart contracts with sound authentication mechanisms. For an account to be able to wield // this power, two things must occur: // - The Authorizer must grant the account the permission to be a relayer for the relevant Vault function. This // means that Balancer governance must approve each individual contract to act as a relayer for the intended // functions. // - Each user must approve the relayer to act on their behalf. // This double protection means users cannot be tricked into approving malicious relayers (because they will not // have been allowed by the Authorizer via governance), nor can malicious relayers approved by a compromised // Authorizer or governance drain user funds, since they would also need to be approved by each individual user. /** * @dev Returns true if `user` has approved `relayer` to act as a relayer for them. */ function hasApprovedRelayer(address user, address relayer) external view returns (bool); /** * @dev Allows `relayer` to act as a relayer for `sender` if `approved` is true, and disallows it otherwise. * * Emits a `RelayerApprovalChanged` event. */ function setRelayerApproval( address sender, address relayer, bool approved ) external; /** * @dev Emitted every time a relayer is approved or disapproved by `setRelayerApproval`. */ event RelayerApprovalChanged(address indexed relayer, address indexed sender, bool approved); // Internal Balance // // Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later // transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination // when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced // gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users. // // Internal Balance management features batching, which means a single contract call can be used to perform multiple // operations of different kinds, with different senders and recipients, at once. /** * @dev Returns `user`'s Internal Balance for a set of tokens. */ function getInternalBalance(address user, IERC20[] memory tokens) external view returns (uint256[] memory); /** * @dev Performs a set of user balance operations, which involve Internal Balance (deposit, withdraw or transfer) * and plain ERC20 transfers using the Vault's allowance. This last feature is particularly useful for relayers, as * it lets integrators reuse a user's Vault allowance. * * For each operation, if the caller is not `sender`, it must be an authorized relayer for them. */ function manageUserBalance(UserBalanceOp[] memory ops) external payable; /** * @dev Data for `manageUserBalance` operations, which include the possibility for ETH to be sent and received without manual WETH wrapping or unwrapping. */ struct UserBalanceOp { UserBalanceOpKind kind; IAsset asset; uint256 amount; address sender; address payable recipient; } // There are four possible operations in `manageUserBalance`: // // - DEPOSIT_INTERNAL // Increases the Internal Balance of the `recipient` account by transferring tokens from the corresponding // `sender`. The sender must have allowed the Vault to use their tokens via `IERC20.approve()`. // // ETH can be used by passing the ETH sentinel value as the asset and forwarding ETH in the call: it will be wrapped // and deposited as WETH. Any ETH amount remaining will be sent back to the caller (not the sender, which is // relevant for relayers). // // Emits an `InternalBalanceChanged` event. // // // - WITHDRAW_INTERNAL // Decreases the Internal Balance of the `sender` account by transferring tokens to the `recipient`. // // ETH can be used by passing the ETH sentinel value as the asset. This will deduct WETH instead, unwrap it and send // it to the recipient as ETH. // // Emits an `InternalBalanceChanged` event. // // // - TRANSFER_INTERNAL // Transfers tokens from the Internal Balance of the `sender` account to the Internal Balance of `recipient`. // // Reverts if the ETH sentinel value is passed. // // Emits an `InternalBalanceChanged` event. // // // - TRANSFER_EXTERNAL // Transfers tokens from `sender` to `recipient`, using the Vault's ERC20 allowance. This is typically used by // relayers, as it lets them reuse a user's Vault allowance. // // Reverts if the ETH sentinel value is passed. // // Emits an `ExternalBalanceTransfer` event. enum UserBalanceOpKind { DEPOSIT_INTERNAL, WITHDRAW_INTERNAL, TRANSFER_INTERNAL, TRANSFER_EXTERNAL } /** * @dev Emitted when a user's Internal Balance changes, either from calls to `manageUserBalance`, or through * interacting with Pools using Internal Balance. * * Because Internal Balance works exclusively with ERC20 tokens, ETH deposits and withdrawals will use the WETH * address. */ event InternalBalanceChanged(address indexed user, IERC20 indexed token, int256 delta); /** * @dev Emitted when a user's Vault ERC20 allowance is used by the Vault to transfer tokens to an external account. */ event ExternalBalanceTransfer(IERC20 indexed token, address indexed sender, address recipient, uint256 amount); // Pools // // There are three specialization settings for Pools, which allow for cheaper swaps at the cost of reduced // functionality: // // - General: no specialization, suited for all Pools. IGeneralPool is used for swap request callbacks, passing the // balance of all tokens in the Pool. These Pools have the largest swap costs (because of the extra storage reads), // which increase with the number of registered tokens. // // - Minimal Swap Info: IMinimalSwapInfoPool is used instead of IGeneralPool, which saves gas by only passing the // balance of the two tokens involved in the swap. This is suitable for some pricing algorithms, like the weighted // constant product one popularized by Balancer V1. Swap costs are smaller compared to general Pools, and are // independent of the number of registered tokens. // // - Two Token: only allows two tokens to be registered. This achieves the lowest possible swap gas cost. Like // minimal swap info Pools, these are called via IMinimalSwapInfoPool. enum PoolSpecialization { GENERAL, MINIMAL_SWAP_INFO, TWO_TOKEN } /** * @dev Registers the caller account as a Pool with a given specialization setting. Returns the Pool's ID, which * is used in all Pool-related functions. Pools cannot be deregistered, nor can the Pool's specialization be * changed. * * The caller is expected to be a smart contract that implements either `IGeneralPool` or `IMinimalSwapInfoPool`, * depending on the chosen specialization setting. This contract is known as the Pool's contract. * * Note that the same contract may register itself as multiple Pools with unique Pool IDs, or in other words, * multiple Pools may share the same contract. * * Emits a `PoolRegistered` event. */ function registerPool(PoolSpecialization specialization) external returns (bytes32); /** * @dev Emitted when a Pool is registered by calling `registerPool`. */ event PoolRegistered(bytes32 indexed poolId, address indexed poolAddress, PoolSpecialization specialization); /** * @dev Returns a Pool's contract address and specialization setting. */ function getPool(bytes32 poolId) external view returns (address, PoolSpecialization); /** * @dev Registers `tokens` for the `poolId` Pool. Must be called by the Pool's contract. * * Pools can only interact with tokens they have registered. Users join a Pool by transferring registered tokens, * exit by receiving registered tokens, and can only swap registered tokens. * * Each token can only be registered once. For Pools with the Two Token specialization, `tokens` must have a length * of two, that is, both tokens must be registered in the same `registerTokens` call, and they must be sorted in * ascending order. * * The `tokens` and `assetManagers` arrays must have the same length, and each entry in these indicates the Asset * Manager for the corresponding token. Asset Managers can manage a Pool's tokens via `managePoolBalance`, * depositing and withdrawing them directly, and can even set their balance to arbitrary amounts. They are therefore * expected to be highly secured smart contracts with sound design principles, and the decision to register an * Asset Manager should not be made lightly. * * Pools can choose not to assign an Asset Manager to a given token by passing in the zero address. Once an Asset * Manager is set, it cannot be changed except by deregistering the associated token and registering again with a * different Asset Manager. * * Emits a `TokensRegistered` event. */ function registerTokens( bytes32 poolId, IERC20[] memory tokens, address[] memory assetManagers ) external; /** * @dev Emitted when a Pool registers tokens by calling `registerTokens`. */ event TokensRegistered(bytes32 indexed poolId, IERC20[] tokens, address[] assetManagers); /** * @dev Deregisters `tokens` for the `poolId` Pool. Must be called by the Pool's contract. * * Only registered tokens (via `registerTokens`) can be deregistered. Additionally, they must have zero total * balance. For Pools with the Two Token specialization, `tokens` must have a length of two, that is, both tokens * must be deregistered in the same `deregisterTokens` call. * * A deregistered token can be re-registered later on, possibly with a different Asset Manager. * * Emits a `TokensDeregistered` event. */ function deregisterTokens(bytes32 poolId, IERC20[] memory tokens) external; /** * @dev Emitted when a Pool deregisters tokens by calling `deregisterTokens`. */ event TokensDeregistered(bytes32 indexed poolId, IERC20[] tokens); /** * @dev Returns detailed information for a Pool's registered token. * * `cash` is the number of tokens the Vault currently holds for the Pool. `managed` is the number of tokens * withdrawn and held outside the Vault by the Pool's token Asset Manager. The Pool's total balance for `token` * equals the sum of `cash` and `managed`. * * Internally, `cash` and `managed` are stored using 112 bits. No action can ever cause a Pool's token `cash`, * `managed` or `total` balance to be greater than 2^112 - 1. * * `lastChangeBlock` is the number of the block in which `token`'s total balance was last modified (via either a * join, exit, swap, or Asset Manager update). This value is useful to avoid so-called 'sandwich attacks', for * example when developing price oracles. A change of zero (e.g. caused by a swap with amount zero) is considered a * change for this purpose, and will update `lastChangeBlock`. * * `assetManager` is the Pool's token Asset Manager. */ function getPoolTokenInfo(bytes32 poolId, IERC20 token) external view returns ( uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager ); /** * @dev Returns a Pool's registered tokens, the total balance for each, and the latest block when *any* of * the tokens' `balances` changed. * * The order of the `tokens` array is the same order that will be used in `joinPool`, `exitPool`, as well as in all * Pool hooks (where applicable). Calls to `registerTokens` and `deregisterTokens` may change this order. * * If a Pool only registers tokens once, and these are sorted in ascending order, they will be stored in the same * order as passed to `registerTokens`. * * Total balances include both tokens held by the Vault and those withdrawn by the Pool's Asset Managers. These are * the amounts used by joins, exits and swaps. For a detailed breakdown of token balances, use `getPoolTokenInfo` * instead. */ function getPoolTokens(bytes32 poolId) external view returns ( IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock ); /** * @dev Called by users to join a Pool, which transfers tokens from `sender` into the Pool's balance. This will * trigger custom Pool behavior, which will typically grant something in return to `recipient` - often tokenized * Pool shares. * * If the caller is not `sender`, it must be an authorized relayer for them. * * The `assets` and `maxAmountsIn` arrays must have the same length, and each entry indicates the maximum amount * to send for each asset. The amounts to send are decided by the Pool and not the Vault: it just enforces * these maximums. * * If joining a Pool that holds WETH, it is possible to send ETH directly: the Vault will do the wrapping. To enable * this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead of the * WETH address. Note that it is not possible to combine ETH and WETH in the same join. Any excess ETH will be sent * back to the caller (not the sender, which is important for relayers). * * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when * interacting with Pools that register and deregister tokens frequently. If sending ETH however, the array must be * sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the final * `assets` array might not be sorted. Pools with no registered tokens cannot be joined. * * If `fromInternalBalance` is true, the caller's Internal Balance will be preferred: ERC20 transfers will only * be made for the difference between the requested amount and Internal Balance (if any). Note that ETH cannot be * withdrawn from Internal Balance: attempting to do so will trigger a revert. * * This causes the Vault to call the `IBasePool.onJoinPool` hook on the Pool's contract, where Pools implement * their own custom logic. This typically requires additional information from the user (such as the expected number * of Pool shares). This can be encoded in the `userData` argument, which is ignored by the Vault and passed * directly to the Pool's contract, as is `recipient`. * * Emits a `PoolBalanceChanged` event. */ function joinPool( bytes32 poolId, address sender, address recipient, JoinPoolRequest memory request ) external payable; struct JoinPoolRequest { IAsset[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; } /** * @dev Called by users to exit a Pool, which transfers tokens from the Pool's balance to `recipient`. This will * trigger custom Pool behavior, which will typically ask for something in return from `sender` - often tokenized * Pool shares. The amount of tokens that can be withdrawn is limited by the Pool's `cash` balance (see * `getPoolTokenInfo`). * * If the caller is not `sender`, it must be an authorized relayer for them. * * The `tokens` and `minAmountsOut` arrays must have the same length, and each entry in these indicates the minimum * token amount to receive for each token contract. The amounts to send are decided by the Pool and not the Vault: * it just enforces these minimums. * * If exiting a Pool that holds WETH, it is possible to receive ETH directly: the Vault will do the unwrapping. To * enable this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead * of the WETH address. Note that it is not possible to combine ETH and WETH in the same exit. * * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when * interacting with Pools that register and deregister tokens frequently. If receiving ETH however, the array must * be sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the * final `assets` array might not be sorted. Pools with no registered tokens cannot be exited. * * If `toInternalBalance` is true, the tokens will be deposited to `recipient`'s Internal Balance. Otherwise, * an ERC20 transfer will be performed. Note that ETH cannot be deposited to Internal Balance: attempting to * do so will trigger a revert. * * `minAmountsOut` is the minimum amount of tokens the user expects to get out of the Pool, for each token in the * `tokens` array. This array must match the Pool's registered tokens. * * This causes the Vault to call the `IBasePool.onExitPool` hook on the Pool's contract, where Pools implement * their own custom logic. This typically requires additional information from the user (such as the expected number * of Pool shares to return). This can be encoded in the `userData` argument, which is ignored by the Vault and * passed directly to the Pool's contract. * * Emits a `PoolBalanceChanged` event. */ function exitPool( bytes32 poolId, address sender, address payable recipient, ExitPoolRequest memory request ) external; struct ExitPoolRequest { IAsset[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; } /** * @dev Emitted when a user joins or exits a Pool by calling `joinPool` or `exitPool`, respectively. */ event PoolBalanceChanged( bytes32 indexed poolId, address indexed liquidityProvider, IERC20[] tokens, int256[] deltas, uint256[] protocolFeeAmounts ); enum PoolBalanceChangeKind { JOIN, EXIT } // Swaps // // Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. To do this, // they need not trust Pool contracts in any way: all security checks are made by the Vault. They must however be // aware of the Pools' pricing algorithms in order to estimate the prices Pools will quote. // // The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence. // In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'), // and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out'). // More complex swaps, such as one token in to multiple tokens out can be achieved by batching together // individual swaps. // // There are two swap kinds: // - 'given in' swaps, where the amount of tokens in (sent to the Pool) is known, and the Pool determines (via the // `onSwap` hook) the amount of tokens out (to send to the recipient). // - 'given out' swaps, where the amount of tokens out (received from the Pool) is known, and the Pool determines // (via the `onSwap` hook) the amount of tokens in (to receive from the sender). // // Additionally, it is possible to chain swaps using a placeholder input amount, which the Vault replaces with // the calculated output of the previous swap. If the previous swap was 'given in', this will be the calculated // tokenOut amount. If the previous swap was 'given out', it will use the calculated tokenIn amount. These extended // swaps are known as 'multihop' swaps, since they 'hop' through a number of intermediate tokens before arriving at // the final intended token. // // In all cases, tokens are only transferred in and out of the Vault (or withdrawn from and deposited into Internal // Balance) after all individual swaps have been completed, and the net token balance change computed. This makes // certain swap patterns, such as multihops, or swaps that interact with the same token pair in multiple Pools, cost // much less gas than they would otherwise. // // It also means that under certain conditions it is possible to perform arbitrage by swapping with multiple // Pools in a way that results in net token movement out of the Vault (profit), with no tokens being sent in (only // updating the Pool's internal accounting). // // To protect users from front-running or the market changing rapidly, they supply a list of 'limits' for each token // involved in the swap, where either the maximum number of tokens to send (by passing a positive value) or the // minimum amount of tokens to receive (by passing a negative value) is specified. // // Additionally, a 'deadline' timestamp can also be provided, forcing the swap to fail if it occurs after // this point in time (e.g. if the transaction failed to be included in a block promptly). // // If interacting with Pools that hold WETH, it is possible to both send and receive ETH directly: the Vault will do // the wrapping and unwrapping. To enable this mechanism, the IAsset sentinel value (the zero address) must be // passed in the `assets` array instead of the WETH address. Note that it is possible to combine ETH and WETH in the // same swap. Any excess ETH will be sent back to the caller (not the sender, which is relevant for relayers). // // Finally, Internal Balance can be used when either sending or receiving tokens. enum SwapKind { GIVEN_IN, GIVEN_OUT } /** * @dev Performs a swap with a single Pool. * * If the swap is 'given in' (the number of tokens to send to the Pool is known), it returns the amount of tokens * taken from the Pool, which must be greater than or equal to `limit`. * * If the swap is 'given out' (the number of tokens to take from the Pool is known), it returns the amount of tokens * sent to the Pool, which must be less than or equal to `limit`. * * Internal Balance usage and the recipient are determined by the `funds` struct. * * Emits a `Swap` event. */ function swap( SingleSwap memory singleSwap, FundManagement memory funds, uint256 limit, uint256 deadline ) external payable returns (uint256); /** * @dev Data for a single swap executed by `swap`. `amount` is either `amountIn` or `amountOut` depending on * the `kind` value. * * `assetIn` and `assetOut` are either token addresses, or the IAsset sentinel value for ETH (the zero address). * Note that Pools never interact with ETH directly: it will be wrapped to or unwrapped from WETH by the Vault. * * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be * used to extend swap behavior. */ struct SingleSwap { bytes32 poolId; SwapKind kind; IAsset assetIn; IAsset assetOut; uint256 amount; bytes userData; } /** * @dev Performs a series of swaps with one or multiple Pools. In each individual swap, the caller determines either * the amount of tokens sent to or received from the Pool, depending on the `kind` value. * * Returns an array with the net Vault asset balance deltas. Positive amounts represent tokens (or ETH) sent to the * Vault, and negative amounts represent tokens (or ETH) sent by the Vault. Each delta corresponds to the asset at * the same index in the `assets` array. * * Swaps are executed sequentially, in the order specified by the `swaps` array. Each array element describes a * Pool, the token to be sent to this Pool, the token to receive from it, and an amount that is either `amountIn` or * `amountOut` depending on the swap kind. * * Multihop swaps can be executed by passing an `amount` value of zero for a swap. This will cause the amount in/out * of the previous swap to be used as the amount in for the current one. In a 'given in' swap, 'tokenIn' must equal * the previous swap's `tokenOut`. For a 'given out' swap, `tokenOut` must equal the previous swap's `tokenIn`. * * The `assets` array contains the addresses of all assets involved in the swaps. These are either token addresses, * or the IAsset sentinel value for ETH (the zero address). Each entry in the `swaps` array specifies tokens in and * out by referencing an index in `assets`. Note that Pools never interact with ETH directly: it will be wrapped to * or unwrapped from WETH by the Vault. * * Internal Balance usage, sender, and recipient are determined by the `funds` struct. The `limits` array specifies * the minimum or maximum amount of each token the vault is allowed to transfer. * * `batchSwap` can be used to make a single swap, like `swap` does, but doing so requires more gas than the * equivalent `swap` call. * * Emits `Swap` events. */ function batchSwap( SwapKind kind, BatchSwapStep[] memory swaps, IAsset[] memory assets, FundManagement memory funds, int256[] memory limits, uint256 deadline ) external payable returns (int256[] memory); /** * @dev Data for each individual swap executed by `batchSwap`. The asset in and out fields are indexes into the * `assets` array passed to that function, and ETH assets are converted to WETH. * * If `amount` is zero, the multihop mechanism is used to determine the actual amount based on the amount in/out * from the previous swap, depending on the swap kind. * * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be * used to extend swap behavior. */ struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; } /** * @dev Emitted for each individual swap performed by `swap` or `batchSwap`. */ event Swap( bytes32 indexed poolId, IERC20 indexed tokenIn, IERC20 indexed tokenOut, uint256 amountIn, uint256 amountOut ); /** * @dev All tokens in a swap are either sent from the `sender` account to the Vault, or from the Vault to the * `recipient` account. * * If the caller is not `sender`, it must be an authorized relayer for them. * * If `fromInternalBalance` is true, the `sender`'s Internal Balance will be preferred, performing an ERC20 * transfer for the difference between the requested amount and the User's Internal Balance (if any). The `sender` * must have allowed the Vault to use their tokens via `IERC20.approve()`. This matches the behavior of * `joinPool`. * * If `toInternalBalance` is true, tokens will be deposited to `recipient`'s internal balance instead of * transferred. This matches the behavior of `exitPool`. * * Note that ETH cannot be deposited to or withdrawn from Internal Balance: attempting to do so will trigger a * revert. */ struct FundManagement { address sender; bool fromInternalBalance; address payable recipient; bool toInternalBalance; } /** * @dev Simulates a call to `batchSwap`, returning an array of Vault asset deltas. Calls to `swap` cannot be * simulated directly, but an equivalent `batchSwap` call can and will yield the exact same result. * * Each element in the array corresponds to the asset at the same index, and indicates the number of tokens (or ETH) * the Vault would take from the sender (if positive) or send to the recipient (if negative). The arguments it * receives are the same that an equivalent `batchSwap` call would receive. * * Unlike `batchSwap`, this function performs no checks on the sender or recipient field in the `funds` struct. * This makes it suitable to be called by off-chain applications via eth_call without needing to hold tokens, * approve them for the Vault, or even know a user's address. * * Note that this function is not 'view' (due to implementation details): the client code must explicitly execute * eth_call instead of eth_sendTransaction. */ function queryBatchSwap( SwapKind kind, BatchSwapStep[] memory swaps, IAsset[] memory assets, FundManagement memory funds ) external returns (int256[] memory assetDeltas); // Flash Loans /** * @dev Performs a 'flash loan', sending tokens to `recipient`, executing the `receiveFlashLoan` hook on it, * and then reverting unless the tokens plus a proportional protocol fee have been returned. * * The `tokens` and `amounts` arrays must have the same length, and each entry in these indicates the loan amount * for each token contract. `tokens` must be sorted in ascending order. * * The 'userData' field is ignored by the Vault, and forwarded as-is to `recipient` as part of the * `receiveFlashLoan` call. * * Emits `FlashLoan` events. */ function flashLoan( IFlashLoanRecipient recipient, IERC20[] memory tokens, uint256[] memory amounts, bytes memory userData ) external; /** * @dev Emitted for each individual flash loan performed by `flashLoan`. */ event FlashLoan(IFlashLoanRecipient indexed recipient, IERC20 indexed token, uint256 amount, uint256 feeAmount); // Asset Management // // Each token registered for a Pool can be assigned an Asset Manager, which is able to freely withdraw the Pool's // tokens from the Vault, deposit them, or assign arbitrary values to its `managed` balance (see // `getPoolTokenInfo`). This makes them extremely powerful and dangerous. Even if an Asset Manager only directly // controls one of the tokens in a Pool, a malicious manager could set that token's balance to manipulate the // prices of the other tokens, and then drain the Pool with swaps. The risk of using Asset Managers is therefore // not constrained to the tokens they are managing, but extends to the entire Pool's holdings. // // However, a properly designed Asset Manager smart contract can be safely used for the Pool's benefit, // for example by lending unused tokens out for interest, or using them to participate in voting protocols. // // This concept is unrelated to the IAsset interface. /** * @dev Performs a set of Pool balance operations, which may be either withdrawals, deposits or updates. * * Pool Balance management features batching, which means a single contract call can be used to perform multiple * operations of different kinds, with different Pools and tokens, at once. * * For each operation, the caller must be registered as the Asset Manager for `token` in `poolId`. */ function managePoolBalance(PoolBalanceOp[] memory ops) external; struct PoolBalanceOp { PoolBalanceOpKind kind; bytes32 poolId; IERC20 token; uint256 amount; } /** * Withdrawals decrease the Pool's cash, but increase its managed balance, leaving the total balance unchanged. * * Deposits increase the Pool's cash, but decrease its managed balance, leaving the total balance unchanged. * * Updates don't affect the Pool's cash balance, but because the managed balance changes, it does alter the total. * The external amount can be either increased or decreased by this call (i.e., reporting a gain or a loss). */ enum PoolBalanceOpKind { WITHDRAW, DEPOSIT, UPDATE } /** * @dev Emitted when a Pool's token Asset Manager alters its balance via `managePoolBalance`. */ event PoolBalanceManaged( bytes32 indexed poolId, address indexed assetManager, IERC20 indexed token, int256 cashDelta, int256 managedDelta ); // Protocol Fees // // Some operations cause the Vault to collect tokens in the form of protocol fees, which can then be withdrawn by // permissioned accounts. // // There are two kinds of protocol fees: // // - flash loan fees: charged on all flash loans, as a percentage of the amounts lent. // // - swap fees: a percentage of the fees charged by Pools when performing swaps. For a number of reasons, including // swap gas costs and interface simplicity, protocol swap fees are not charged on each individual swap. Rather, // Pools are expected to keep track of how much they have charged in swap fees, and pay any outstanding debts to the // Vault when they are joined or exited. This prevents users from joining a Pool with unpaid debt, as well as // exiting a Pool in debt without first paying their share. /** * @dev Returns the current protocol fee module. */ function getProtocolFeesCollector() external view returns (ProtocolFeesCollector); /** * @dev Safety mechanism to pause most Vault operations in the event of an emergency - typically detection of an * error in some part of the system. * * The Vault can only be paused during an initial time period, after which pausing is forever disabled. * * While the contract is paused, the following features are disabled: * - depositing and transferring internal balance * - transferring external balance (using the Vault's allowance) * - swaps * - joining Pools * - Asset Manager interactions * * Internal Balance can still be withdrawn, and Pools exited. */ function setPaused(bool paused) external; /** * @dev Returns the Vault's WETH instance. */ function WETH() external view returns (IWETH); // solhint-disable-previous-line func-name-mixedcase }
/contracts/interfaces/IWETH.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "../../lib/openzeppelin/IERC20.sol"; /** * @dev Interface for the WETH token contract used internally for wrapping and unwrapping, to support * sending and receiving ETH in joins, swaps, and internal balance deposits and withdrawals. */ interface IWETH is IERC20 { function deposit() external payable; function withdraw(uint256 amount) external; }
/lib/helpers/AssetHelpers.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "../openzeppelin/IERC20.sol"; import "../../contracts/interfaces/IAsset.sol"; import "../../contracts/interfaces/IWETH.sol"; abstract contract AssetHelpers { // solhint-disable-next-line var-name-mixedcase IWETH private immutable _weth; // Sentinel value used to indicate WETH with wrapping/unwrapping semantics. The zero address is a good choice for // multiple reasons: it is cheap to pass as a calldata argument, it is a known invalid token and non-contract, and // it is an address Pools cannot register as a token. address private constant _ETH = address(0); constructor(IWETH weth) { _weth = weth; } // solhint-disable-next-line func-name-mixedcase function _WETH() internal view returns (IWETH) { return _weth; } /** * @dev Returns true if `asset` is the sentinel value that represents ETH. */ function _isETH(IAsset asset) internal pure returns (bool) { return address(asset) == _ETH; } /** * @dev Translates `asset` into an equivalent IERC20 token address. If `asset` represents ETH, it will be translated * to the WETH contract. */ function _translateToIERC20(IAsset asset) internal view returns (IERC20) { return _isETH(asset) ? _WETH() : _asIERC20(asset); } /** * @dev Same as `_translateToIERC20(IAsset)`, but for an entire array. */ function _translateToIERC20(IAsset[] memory assets) internal view returns (IERC20[] memory) { IERC20[] memory tokens = new IERC20[](assets.length); for (uint256 i = 0; i < assets.length; ++i) { tokens[i] = _translateToIERC20(assets[i]); } return tokens; } /** * @dev Interprets `asset` as an IERC20 token. This function should only be called on `asset` if `_isETH` previously * returned false for it, that is, if `asset` is guaranteed not to be the ETH sentinel value. */ function _asIERC20(IAsset asset) internal pure returns (IERC20) { return IERC20(address(asset)); } }
/lib/helpers/Authentication.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "./BalancerErrors.sol"; import "./IAuthentication.sol"; /** * @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); }
/lib/helpers/BalancerErrors.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; // solhint-disable /** * @dev Reverts if `condition` is false, with a revert reason containing `errorCode`. Only codes up to 999 are * supported. */ function _require(bool condition, uint256 errorCode) pure { if (!condition) _revert(errorCode); } /** * @dev Reverts with a revert reason containing `errorCode`. Only codes up to 999 are supported. */ function _revert(uint256 errorCode) pure { // We're going to dynamically create a revert string based on the error code, with the following format: // 'BAL#{errorCode}' // where the code is left-padded with zeroes to three digits (so they range from 000 to 999). // // We don't have revert strings embedded in the contract to save bytecode size: it takes much less space to store a // number (8 to 16 bits) than the individual string characters. // // The dynamic string creation algorithm that follows could be implemented in Solidity, but assembly allows for a // much denser implementation, again saving bytecode size. Given this function unconditionally reverts, this is a // safe place to rely on it without worrying about how its usage might affect e.g. memory contents. assembly { // First, we need to compute the ASCII representation of the error code. We assume that it is in the 0-999 // range, so we only need to convert three digits. To convert the digits to ASCII, we add 0x30, the value for // the '0' character. let units := add(mod(errorCode, 10), 0x30) errorCode := div(errorCode, 10) let tenths := add(mod(errorCode, 10), 0x30) errorCode := div(errorCode, 10) let hundreds := add(mod(errorCode, 10), 0x30) // With the individual characters, we can now construct the full string. The "BAL#" part is a known constant // (0x42414c23): we simply shift this by 24 (to provide space for the 3 bytes of the error code), and add the // characters to it, each shifted by a multiple of 8. // The revert reason is then shifted left by 200 bits (256 minus the length of the string, 7 characters * 8 bits // per character = 56) to locate it in the most significant part of the 256 slot (the beginning of a byte // array). let revertReason := shl(200, add(0x42414c23000000, add(add(units, shl(8, tenths)), shl(16, hundreds)))) // We can now encode the reason in memory, which can be safely overwritten as we're about to revert. The encoded // message will have the following layout: // [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ] // The Solidity revert reason identifier is 0x08c739a0, the function selector of the Error(string) function. We // also write zeroes to the next 28 bytes of memory, but those are about to be overwritten. mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000) // Next is the offset to the location of the string, which will be placed immediately after (20 bytes away). mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020) // The string length is fixed: 7 characters. mstore(0x24, 7) // Finally, the string itself is stored. mstore(0x44, revertReason) // Even if the string is only 7 bytes long, we need to return a full 32 byte slot containing it. The length of // the encoded message is therefore 4 + 32 + 32 + 32 = 100. revert(0, 100) } } library Errors { // Math uint256 internal constant ADD_OVERFLOW = 0; uint256 internal constant SUB_OVERFLOW = 1; uint256 internal constant SUB_UNDERFLOW = 2; uint256 internal constant MUL_OVERFLOW = 3; uint256 internal constant ZERO_DIVISION = 4; uint256 internal constant DIV_INTERNAL = 5; uint256 internal constant X_OUT_OF_BOUNDS = 6; uint256 internal constant Y_OUT_OF_BOUNDS = 7; uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8; uint256 internal constant INVALID_EXPONENT = 9; // Input uint256 internal constant OUT_OF_BOUNDS = 100; uint256 internal constant UNSORTED_ARRAY = 101; uint256 internal constant UNSORTED_TOKENS = 102; uint256 internal constant INPUT_LENGTH_MISMATCH = 103; uint256 internal constant ZERO_TOKEN = 104; // Shared pools uint256 internal constant MIN_TOKENS = 200; uint256 internal constant MAX_TOKENS = 201; uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202; uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203; uint256 internal constant MINIMUM_BPT = 204; uint256 internal constant CALLER_NOT_VAULT = 205; uint256 internal constant UNINITIALIZED = 206; uint256 internal constant BPT_IN_MAX_AMOUNT = 207; uint256 internal constant BPT_OUT_MIN_AMOUNT = 208; uint256 internal constant EXPIRED_PERMIT = 209; // Pools uint256 internal constant MIN_AMP = 300; uint256 internal constant MAX_AMP = 301; uint256 internal constant MIN_WEIGHT = 302; uint256 internal constant MAX_STABLE_TOKENS = 303; uint256 internal constant MAX_IN_RATIO = 304; uint256 internal constant MAX_OUT_RATIO = 305; uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306; uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307; uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308; uint256 internal constant INVALID_TOKEN = 309; uint256 internal constant UNHANDLED_JOIN_KIND = 310; uint256 internal constant ZERO_INVARIANT = 311; // Lib uint256 internal constant REENTRANCY = 400; uint256 internal constant SENDER_NOT_ALLOWED = 401; uint256 internal constant PAUSED = 402; uint256 internal constant PAUSE_WINDOW_EXPIRED = 403; uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404; uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405; uint256 internal constant INSUFFICIENT_BALANCE = 406; uint256 internal constant INSUFFICIENT_ALLOWANCE = 407; uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408; uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409; uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410; uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411; uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412; uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413; uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414; uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415; uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416; uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417; uint256 internal constant SAFE_ERC20_CALL_FAILED = 418; uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419; uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420; uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421; uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422; uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423; uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424; uint256 internal constant BUFFER_PERIOD_EXPIRED = 425; // Vault uint256 internal constant INVALID_POOL_ID = 500; uint256 internal constant CALLER_NOT_POOL = 501; uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502; uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503; uint256 internal constant INVALID_SIGNATURE = 504; uint256 internal constant EXIT_BELOW_MIN = 505; uint256 internal constant JOIN_ABOVE_MAX = 506; uint256 internal constant SWAP_LIMIT = 507; uint256 internal constant SWAP_DEADLINE = 508; uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509; uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510; uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511; uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512; uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513; uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514; uint256 internal constant INVALID_POST_LOAN_BALANCE = 515; uint256 internal constant INSUFFICIENT_ETH = 516; uint256 internal constant UNALLOCATED_ETH = 517; uint256 internal constant ETH_TRANSFER = 518; uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519; uint256 internal constant TOKENS_MISMATCH = 520; uint256 internal constant TOKEN_NOT_REGISTERED = 521; uint256 internal constant TOKEN_ALREADY_REGISTERED = 522; uint256 internal constant TOKENS_ALREADY_SET = 523; uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524; uint256 internal constant NONZERO_TOKEN_BALANCE = 525; uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526; uint256 internal constant POOL_NO_TOKENS = 527; uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528; // Fees uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600; uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601; uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602; }
/lib/helpers/IAuthentication.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; interface IAuthentication { /** * @dev Returns the action identifier associated with the external function described by `selector`. */ function getActionId(bytes4 selector) external view returns (bytes32); }
/lib/helpers/ISignaturesValidator.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; /** * @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); }
/lib/helpers/ITemporarilyPausable.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; /** * @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 ); }
/lib/helpers/InputHelpers.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "../openzeppelin/IERC20.sol"; import "./BalancerErrors.sol"; import "../../contracts/interfaces/IAsset.sol"; library InputHelpers { function ensureInputLengthMatch(uint256 a, uint256 b) internal pure { _require(a == b, Errors.INPUT_LENGTH_MISMATCH); } function ensureInputLengthMatch( uint256 a, uint256 b, uint256 c ) internal pure { _require(a == b && b == c, Errors.INPUT_LENGTH_MISMATCH); } function ensureArrayIsSorted(IAsset[] memory array) internal pure { address[] memory addressArray; // solhint-disable-next-line no-inline-assembly assembly { addressArray := array } ensureArrayIsSorted(addressArray); } function ensureArrayIsSorted(IERC20[] memory array) internal pure { address[] memory addressArray; // solhint-disable-next-line no-inline-assembly assembly { addressArray := array } ensureArrayIsSorted(addressArray); } function ensureArrayIsSorted(address[] memory array) internal pure { if (array.length < 2) { return; } address previous = array[0]; for (uint256 i = 1; i < array.length; ++i) { address current = array[i]; _require(previous < current, Errors.UNSORTED_ARRAY); previous = current; } } }
/lib/helpers/SignaturesValidator.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "./BalancerErrors.sol"; import "./ISignaturesValidator.sol"; import "../openzeppelin/EIP712.sol"; /** * @dev Utility for signing Solidity function calls. * * This contract relies on the fact that Solidity contracts can be called with extra calldata, and enables * meta-transaction schemes by appending an EIP712 signature of the original calldata at the end. * * Derived contracts must implement the `_typeHash` function to map function selectors to EIP712 structs. */ abstract contract SignaturesValidator is ISignaturesValidator, EIP712 { // The appended data consists of a deadline, plus the [v,r,s] signature. For simplicity, we use a full 256 bit slot // for each of these values, even if 'v' is typically an 8 bit value. uint256 internal constant _EXTRA_CALLDATA_LENGTH = 4 * 32; // Replay attack prevention for each user. mapping(address => uint256) internal _nextNonce; constructor(string memory name) EIP712(name, "1") { // solhint-disable-previous-line no-empty-blocks } function getDomainSeparator() external view override returns (bytes32) { return _domainSeparatorV4(); } function getNextNonce(address user) external view override returns (uint256) { return _nextNonce[user]; } /** * @dev Reverts with `errorCode` unless a valid signature for `user` was appended to the calldata. */ function _validateSignature(address user, uint256 errorCode) internal { uint256 nextNonce = _nextNonce[user]++; _require(_isSignatureValid(user, nextNonce), errorCode); } function _isSignatureValid(address user, uint256 nonce) private view returns (bool) { uint256 deadline = _deadline(); // The deadline is timestamp-based: it should not be relied upon for sub-minute accuracy. // solhint-disable-next-line not-rely-on-time if (deadline < block.timestamp) { return false; } bytes32 typeHash = _typeHash(); if (typeHash == bytes32(0)) { // Prevent accidental signature validation for functions that don't have an associated type hash. return false; } // All type hashes have this format: (bytes calldata, address sender, uint256 nonce, uint256 deadline). bytes32 structHash = keccak256(abi.encode(typeHash, keccak256(_calldata()), msg.sender, nonce, deadline)); bytes32 digest = _hashTypedDataV4(structHash); (uint8 v, bytes32 r, bytes32 s) = _signature(); address recoveredAddress = ecrecover(digest, v, r, s); // ecrecover returns the zero address on recover failure, so we need to handle that explicitly. return recoveredAddress != address(0) && recoveredAddress == user; } /** * @dev Returns the EIP712 type hash for the current entry point function, which can be identified by its function * selector (available as `msg.sig`). * * The type hash must conform to the following format: * <name>(bytes calldata, address sender, uint256 nonce, uint256 deadline) * * If 0x00, all signatures will be considered invalid. */ function _typeHash() internal view virtual returns (bytes32); /** * @dev Extracts the signature deadline from extra calldata. * * This function returns bogus data if no signature is included. */ function _deadline() internal pure returns (uint256) { // The deadline is the first extra argument at the end of the original calldata. return uint256(_decodeExtraCalldataWord(0)); } /** * @dev Extracts the signature parameters from extra calldata. * * This function returns bogus data if no signature is included. This is not a security risk, as that data would not * be considered a valid signature in the first place. */ function _signature() internal pure returns ( uint8 v, bytes32 r, bytes32 s ) { // v, r and s are appended after the signature deadline, in that order. v = uint8(uint256(_decodeExtraCalldataWord(0x20))); r = _decodeExtraCalldataWord(0x40); s = _decodeExtraCalldataWord(0x60); } /** * @dev Returns the original calldata, without the extra bytes containing the signature. * * This function returns bogus data if no signature is included. */ function _calldata() internal pure returns (bytes memory result) { result = msg.data; // A calldata to memory assignment results in memory allocation and copy of contents. if (result.length > _EXTRA_CALLDATA_LENGTH) { // solhint-disable-next-line no-inline-assembly assembly { // We simply overwrite the array length with the reduced one. mstore(result, sub(calldatasize(), _EXTRA_CALLDATA_LENGTH)) } } } /** * @dev Returns a 256 bit word from 'extra' calldata, at some offset from the expected end of the original calldata. * * This function returns bogus data if no signature is included. */ function _decodeExtraCalldataWord(uint256 offset) private pure returns (bytes32 result) { // solhint-disable-next-line no-inline-assembly assembly { result := calldataload(add(sub(calldatasize(), _EXTRA_CALLDATA_LENGTH), offset)) } } }
/lib/helpers/TemporarilyPausable.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "./BalancerErrors.sol"; import "./ITemporarilyPausable.sol"; /** * @dev Allows for a contract to be paused during an initial period after deployment, disabling functionality. Can be * used as an emergency switch in case a security vulnerability or threat is identified. * * The contract can only be paused during the Pause Window, a period that starts at deployment. It can also be * unpaused and repaused any number of times during this period. This is intended to serve as a safety measure: it lets * system managers react quickly to potentially dangerous situations, knowing that this action is reversible if careful * analysis later determines there was a false alarm. * * If the contract is paused when the Pause Window finishes, it will remain in the paused state through an additional * Buffer Period, after which it will be automatically unpaused forever. This is to ensure there is always enough time * to react to an emergency, even if the threat is discovered shortly before the Pause Window expires. * * Note that since the contract can only be paused within the Pause Window, unpausing during the Buffer Period is * irreversible. */ abstract contract TemporarilyPausable is ITemporarilyPausable { // The Pause Window and Buffer Period are timestamp-based: they should not be relied upon for sub-minute accuracy. // solhint-disable not-rely-on-time uint256 private constant _MAX_PAUSE_WINDOW_DURATION = 90 days; uint256 private constant _MAX_BUFFER_PERIOD_DURATION = 30 days; uint256 private immutable _pauseWindowEndTime; uint256 private immutable _bufferPeriodEndTime; bool private _paused; constructor(uint256 pauseWindowDuration, uint256 bufferPeriodDuration) { _require(pauseWindowDuration <= _MAX_PAUSE_WINDOW_DURATION, Errors.MAX_PAUSE_WINDOW_DURATION); _require(bufferPeriodDuration <= _MAX_BUFFER_PERIOD_DURATION, Errors.MAX_BUFFER_PERIOD_DURATION); uint256 pauseWindowEndTime = block.timestamp + pauseWindowDuration; _pauseWindowEndTime = pauseWindowEndTime; _bufferPeriodEndTime = pauseWindowEndTime + bufferPeriodDuration; } /** * @dev Reverts if the contract is paused. */ modifier whenNotPaused() { _ensureNotPaused(); _; } /** * @dev Returns the current contract pause status, as well as the end times of the Pause Window and Buffer * Period. */ function getPausedState() external view override returns ( bool paused, uint256 pauseWindowEndTime, uint256 bufferPeriodEndTime ) { paused = !_isNotPaused(); pauseWindowEndTime = _getPauseWindowEndTime(); bufferPeriodEndTime = _getBufferPeriodEndTime(); } /** * @dev Sets the pause state to `paused`. The contract can only be paused until the end of the Pause Window, and * unpaused until the end of the Buffer Period. * * Once the Buffer Period expires, this function reverts unconditionally. */ function _setPaused(bool paused) internal { if (paused) { _require(block.timestamp < _getPauseWindowEndTime(), Errors.PAUSE_WINDOW_EXPIRED); } else { _require(block.timestamp < _getBufferPeriodEndTime(), Errors.BUFFER_PERIOD_EXPIRED); } _paused = paused; emit PausedStateChanged(paused); } /** * @dev Reverts if the contract is paused. */ function _ensureNotPaused() internal view { _require(_isNotPaused(), Errors.PAUSED); } /** * @dev Returns true if the contract is unpaused. * * Once the Buffer Period expires, the gas cost of calling this function is reduced dramatically, as storage is no * longer accessed. */ function _isNotPaused() internal view returns (bool) { // After the Buffer Period, the (inexpensive) timestamp check short-circuits the storage access. return block.timestamp > _getBufferPeriodEndTime() || !_paused; } // These getters lead to reduced bytecode size by inlining the immutable variables in a single place. function _getPauseWindowEndTime() private view returns (uint256) { return _pauseWindowEndTime; } function _getBufferPeriodEndTime() private view returns (uint256) { return _bufferPeriodEndTime; } }
/lib/math/FixedPoint.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 solidity ^0.7.0; import "./LogExpMath.sol"; import "../helpers/BalancerErrors.sol"; /* solhint-disable private-vars-leading-underscore */ library FixedPoint { uint256 internal constant ONE = 1e18; // 18 decimal places uint256 internal constant MAX_POW_RELATIVE_ERROR = 10000; // 10^(-14) // Minimum base for the power function when the exponent is 'free' (larger than ONE). uint256 internal constant MIN_POW_BASE_FREE_EXPONENT = 0.7e18; function add(uint256 a, uint256 b) internal pure returns (uint256) { // Fixed Point addition is the same as regular checked addition uint256 c = a + b; _require(c >= a, Errors.ADD_OVERFLOW); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { // Fixed Point addition is the same as regular checked addition _require(b <= a, Errors.SUB_OVERFLOW); uint256 c = a - b; return c; } function mulDown(uint256 a, uint256 b) internal pure returns (uint256) { uint256 product = a * b; _require(a == 0 || product / a == b, Errors.MUL_OVERFLOW); return product / ONE; } function mulUp(uint256 a, uint256 b) internal pure returns (uint256) { uint256 product = a * b; _require(a == 0 || product / a == b, Errors.MUL_OVERFLOW); if (product == 0) { return 0; } else { // The traditional divUp formula is: // divUp(x, y) := (x + y - 1) / y // To avoid intermediate overflow in the addition, we distribute the division and get: // divUp(x, y) := (x - 1) / y + 1 // Note that this requires x != 0, which we already tested for. return ((product - 1) / ONE) + 1; } } function divDown(uint256 a, uint256 b) internal pure returns (uint256) { _require(b != 0, Errors.ZERO_DIVISION); if (a == 0) { return 0; } else { uint256 aInflated = a * ONE; _require(aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow return aInflated / b; } } function divUp(uint256 a, uint256 b) internal pure returns (uint256) { _require(b != 0, Errors.ZERO_DIVISION); if (a == 0) { return 0; } else { uint256 aInflated = a * ONE; _require(aInflated / a == ONE, Errors.DIV_INTERNAL); // mul overflow // The traditional divUp formula is: // divUp(x, y) := (x + y - 1) / y // To avoid intermediate overflow in the addition, we distribute the division and get: // divUp(x, y) := (x - 1) / y + 1 // Note that this requires x != 0, which we already tested for. return ((aInflated - 1) / b) + 1; } } /** * @dev Returns x^y, assuming both are fixed point numbers, rounding down. The result is guaranteed to not be above * the true value (that is, the error function expected - actual is always positive). */ function powDown(uint256 x, uint256 y) internal pure returns (uint256) { uint256 raw = LogExpMath.pow(x, y); uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1); if (raw < maxError) { return 0; } else { return sub(raw, maxError); } } /** * @dev Returns x^y, assuming both are fixed point numbers, rounding up. The result is guaranteed to not be below * the true value (that is, the error function expected - actual is always negative). */ function powUp(uint256 x, uint256 y) internal pure returns (uint256) { uint256 raw = LogExpMath.pow(x, y); uint256 maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), 1); return add(raw, maxError); } /** * @dev Returns the complement of a value (1 - x), capped to 0 if x is larger than 1. * * Useful when computing the complement for values with some level of relative error, as it strips this error and * prevents intermediate negative values. */ function complement(uint256 x) internal pure returns (uint256) { return (x < ONE) ? (ONE - x) : 0; } }
/lib/math/LogExpMath.sol
// SPDX-License-Identifier: GPL-3.0-or-later // 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 internal License for more details. // You should have received a copy of the GNU General internal License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; /* solhint-disable */ /** * @dev Exponentiation and logarithm functions for 18 decimal fixed point numbers (both base and exponent/argument). * * Exponentiation and logarithm with arbitrary bases (x^y and log_x(y)) are implemented by conversion to natural * exponentiation and logarithm (where the base is Euler's number). * * @author Fernando Martinelli - @fernandomartinelli * @author Sergio Yuhjtman - @sergioyuhjtman * @author Daniel Fernandez - @dmf7z */ library LogExpMath { // All fixed point multiplications and divisions are inlined. This means we need to divide by ONE when multiplying // two numbers, and multiply by ONE when dividing them. // All arguments and return values are 18 decimal fixed point numbers. int256 constant ONE_18 = 1e18; // Internally, intermediate values are computed with higher precision as 20 decimal fixed point numbers, and in the // case of ln36, 36 decimals. int256 constant ONE_20 = 1e20; int256 constant ONE_36 = 1e36; // The domain of natural exponentiation is bound by the word size and number of decimals used. // // Because internally the result will be stored using 20 decimals, the largest possible result is // (2^255 - 1) / 10^20, which makes the largest exponent ln((2^255 - 1) / 10^20) = 130.700829182905140221. // The smallest possible result is 10^(-18), which makes largest negative argument // ln(10^(-18)) = -41.446531673892822312. // We use 130.0 and -41.0 to have some safety margin. int256 constant MAX_NATURAL_EXPONENT = 130e18; int256 constant MIN_NATURAL_EXPONENT = -41e18; // Bounds for ln_36's argument. Both ln(0.9) and ln(1.1) can be represented with 36 decimal places in a fixed point // 256 bit integer. int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17; int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17; uint256 constant MILD_EXPONENT_BOUND = 2**254 / uint256(ONE_20); // 18 decimal constants int256 constant x0 = 128000000000000000000; // 2ˆ7 int256 constant a0 = 38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals) int256 constant x1 = 64000000000000000000; // 2ˆ6 int256 constant a1 = 6235149080811616882910000000; // eˆ(x1) (no decimals) // 20 decimal constants int256 constant x2 = 3200000000000000000000; // 2ˆ5 int256 constant a2 = 7896296018268069516100000000000000; // eˆ(x2) int256 constant x3 = 1600000000000000000000; // 2ˆ4 int256 constant a3 = 888611052050787263676000000; // eˆ(x3) int256 constant x4 = 800000000000000000000; // 2ˆ3 int256 constant a4 = 298095798704172827474000; // eˆ(x4) int256 constant x5 = 400000000000000000000; // 2ˆ2 int256 constant a5 = 5459815003314423907810; // eˆ(x5) int256 constant x6 = 200000000000000000000; // 2ˆ1 int256 constant a6 = 738905609893065022723; // eˆ(x6) int256 constant x7 = 100000000000000000000; // 2ˆ0 int256 constant a7 = 271828182845904523536; // eˆ(x7) int256 constant x8 = 50000000000000000000; // 2ˆ-1 int256 constant a8 = 164872127070012814685; // eˆ(x8) int256 constant x9 = 25000000000000000000; // 2ˆ-2 int256 constant a9 = 128402541668774148407; // eˆ(x9) int256 constant x10 = 12500000000000000000; // 2ˆ-3 int256 constant a10 = 113314845306682631683; // eˆ(x10) int256 constant x11 = 6250000000000000000; // 2ˆ-4 int256 constant a11 = 106449445891785942956; // eˆ(x11) /** * @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent. * * Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`. */ function pow(uint256 x, uint256 y) internal pure returns (uint256) { if (y == 0) { // We solve the 0^0 indetermination by making it equal one. return uint256(ONE_18); } if (x == 0) { return 0; } // Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to // arrive at that result. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means // x^y = exp(y * ln(x)). // The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range. _require(x < 2**255, Errors.X_OUT_OF_BOUNDS); int256 x_int256 = int256(x); // We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In // both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end. // This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range. _require(y < MILD_EXPONENT_BOUND, Errors.Y_OUT_OF_BOUNDS); int256 y_int256 = int256(y); int256 logx_times_y; if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) { int256 ln_36_x = ln_36(x_int256); // ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just // bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal // multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the // (downscaled) last 18 decimals. logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18); } else { logx_times_y = ln(x_int256) * y_int256; } logx_times_y /= ONE_18; // Finally, we compute exp(y * ln(x)) to arrive at x^y _require( MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT, Errors.PRODUCT_OUT_OF_BOUNDS ); return uint256(exp(logx_times_y)); } /** * @dev Natural exponentiation (e^x) with signed 18 decimal fixed point exponent. * * Reverts if `x` is smaller than MIN_NATURAL_EXPONENT, or larger than `MAX_NATURAL_EXPONENT`. */ function exp(int256 x) internal pure returns (int256) { _require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, Errors.INVALID_EXPONENT); if (x < 0) { // We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since it // fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT). // Fixed point division requires multiplying by ONE_18. return ((ONE_18 * ONE_18) / exp(-x)); } // First, we use the fact that e^(x+y) = e^x * e^y to decompose x into a sum of powers of two, which we call x_n, // where x_n == 2^(7 - n), and e^x_n = a_n has been precomputed. We choose the first x_n, x0, to equal 2^7 // because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the // decomposition. // At the end of this process we will have the product of all e^x_n = a_n that apply, and the remainder of this // decomposition, which will be lower than the smallest x_n. // exp(x) = k_0 * a_0 * k_1 * a_1 * ... + k_n * a_n * exp(remainder), where each k_n equals either 0 or 1. // We mutate x by subtracting x_n, making it the remainder of the decomposition. // The first two a_n (e^(2^7) and e^(2^6)) are too large if stored as 18 decimal numbers, and could cause // intermediate overflows. Instead we store them as plain integers, with 0 decimals. // Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in the // decomposition. // For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so deduct // it and compute the accumulated product. int256 firstAN; if (x >= x0) { x -= x0; firstAN = a0; } else if (x >= x1) { x -= x1; firstAN = a1; } else { firstAN = 1; // One with no decimal places } // We now transform x into a 20 decimal fixed point number, to have enhanced precision when computing the // smaller terms. x *= 100; // `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed point // one. Recall that fixed point multiplication requires dividing by ONE_20. int256 product = ONE_20; if (x >= x2) { x -= x2; product = (product * a2) / ONE_20; } if (x >= x3) { x -= x3; product = (product * a3) / ONE_20; } if (x >= x4) { x -= x4; product = (product * a4) / ONE_20; } if (x >= x5) { x -= x5; product = (product * a5) / ONE_20; } if (x >= x6) { x -= x6; product = (product * a6) / ONE_20; } if (x >= x7) { x -= x7; product = (product * a7) / ONE_20; } if (x >= x8) { x -= x8; product = (product * a8) / ONE_20; } if (x >= x9) { x -= x9; product = (product * a9) / ONE_20; } // x10 and x11 are unnecessary here since we have high enough precision already. // Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor series // expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!). int256 seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places. int256 term; // Each term in the sum, where the nth term is (x^n / n!). // The first term is simply x. term = x; seriesSum += term; // Each term (x^n / n!) equals the previous one times x, divided by n. Since x is a fixed point number, // multiplying by it requires dividing by ONE_20, but dividing by the non-fixed point n values does not. term = ((term * x) / ONE_20) / 2; seriesSum += term; term = ((term * x) / ONE_20) / 3; seriesSum += term; term = ((term * x) / ONE_20) / 4; seriesSum += term; term = ((term * x) / ONE_20) / 5; seriesSum += term; term = ((term * x) / ONE_20) / 6; seriesSum += term; term = ((term * x) / ONE_20) / 7; seriesSum += term; term = ((term * x) / ONE_20) / 8; seriesSum += term; term = ((term * x) / ONE_20) / 9; seriesSum += term; term = ((term * x) / ONE_20) / 10; seriesSum += term; term = ((term * x) / ONE_20) / 11; seriesSum += term; term = ((term * x) / ONE_20) / 12; seriesSum += term; // 12 Taylor terms are sufficient for 18 decimal precision. // We now have the first a_n (with no decimals), and the product of all other a_n present, and the Taylor // approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to multiply // all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer multiplication), // and then drop two digits to return an 18 decimal value. return (((product * seriesSum) / ONE_20) * firstAN) / 100; } /** * @dev Natural logarithm (ln(a)) with signed 18 decimal fixed point argument. */ function ln(int256 a) internal pure returns (int256) { // The real natural logarithm is not defined for negative numbers or zero. _require(a > 0, Errors.OUT_OF_BOUNDS); if (a < ONE_18) { // Since ln(a^k) = k * ln(a), we can compute ln(a) as ln(a) = ln((1/a)^(-1)) = - ln((1/a)). If a is less // than one, 1/a will be greater than one, and this if statement will not be entered in the recursive call. // Fixed point division requires multiplying by ONE_18. return (-ln((ONE_18 * ONE_18) / a)); } // First, we use the fact that ln^(a * b) = ln(a) + ln(b) to decompose ln(a) into a sum of powers of two, which // we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n (that is, // ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers cannot // be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a. // At the end of this process we will have the sum of all x_n = ln(a_n) that apply, and the remainder of this // decomposition, which will be lower than the smallest a_n. // ln(a) = k_0 * x_0 + k_1 * x_1 + ... + k_n * x_n + ln(remainder), where each k_n equals either 0 or 1. // We mutate a by subtracting a_n, making it the remainder of the decomposition. // For reasons related to how `exp` works, the first two a_n (e^(2^7) and e^(2^6)) are not stored as fixed point // numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply them by // ONE_18 to convert them to fixed point. // For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so divide // by it and compute the accumulated sum. int256 sum = 0; if (a >= a0 * ONE_18) { a /= a0; // Integer, not fixed point division sum += x0; } if (a >= a1 * ONE_18) { a /= a1; // Integer, not fixed point division sum += x1; } // All other a_n and x_n are stored as 20 digit fixed point numbers, so we convert the sum and a to this format. sum *= 100; a *= 100; // Because further a_n are 20 digit fixed point numbers, we multiply by ONE_20 when dividing by them. if (a >= a2) { a = (a * ONE_20) / a2; sum += x2; } if (a >= a3) { a = (a * ONE_20) / a3; sum += x3; } if (a >= a4) { a = (a * ONE_20) / a4; sum += x4; } if (a >= a5) { a = (a * ONE_20) / a5; sum += x5; } if (a >= a6) { a = (a * ONE_20) / a6; sum += x6; } if (a >= a7) { a = (a * ONE_20) / a7; sum += x7; } if (a >= a8) { a = (a * ONE_20) / a8; sum += x8; } if (a >= a9) { a = (a * ONE_20) / a9; sum += x9; } if (a >= a10) { a = (a * ONE_20) / a10; sum += x10; } if (a >= a11) { a = (a * ONE_20) / a11; sum += x11; } // a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor series // that converges rapidly for values of `a` close to one - the same one used in ln_36. // Let z = (a - 1) / (a + 1). // ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1)) // Recall that 20 digit fixed point division requires multiplying by ONE_20, and multiplication requires // division by ONE_20. int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20); int256 z_squared = (z * z) / ONE_20; // num is the numerator of the series: the z^(2 * n + 1) term int256 num = z; // seriesSum holds the accumulated sum of each term in the series, starting with the initial z int256 seriesSum = num; // In each step, the numerator is multiplied by z^2 num = (num * z_squared) / ONE_20; seriesSum += num / 3; num = (num * z_squared) / ONE_20; seriesSum += num / 5; num = (num * z_squared) / ONE_20; seriesSum += num / 7; num = (num * z_squared) / ONE_20; seriesSum += num / 9; num = (num * z_squared) / ONE_20; seriesSum += num / 11; // 6 Taylor terms are sufficient for 36 decimal precision. // Finally, we multiply by 2 (non fixed point) to compute ln(remainder) seriesSum *= 2; // We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder (both // with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18 decimal // value. return (sum + seriesSum) / 100; } /** * @dev Logarithm (log(arg, base), with signed 18 decimal fixed point base and argument argument. */ function log(int256 arg, int256 base) internal pure returns (int256) { // This performs a simple base change: log(arg, base) = ln(arg) / ln(base). // Both logBase and logArg are computed as 36 decimal fixed point numbers, either by using ln_36, or by // upscaling. int256 logBase; if (LN_36_LOWER_BOUND < base && base < LN_36_UPPER_BOUND) { logBase = ln_36(base); } else { logBase = ln(base) * ONE_18; } int256 logArg; if (LN_36_LOWER_BOUND < arg && arg < LN_36_UPPER_BOUND) { logArg = ln_36(arg); } else { logArg = ln(arg) * ONE_18; } // When dividing, we multiply by ONE_18 to arrive at a result with 18 decimal places return (logArg * ONE_18) / logBase; } /** * @dev High precision (36 decimal places) natural logarithm (ln(x)) with signed 18 decimal fixed point argument, * for x close to one. * * Should only be used if x is between LN_36_LOWER_BOUND and LN_36_UPPER_BOUND. */ function ln_36(int256 x) private pure returns (int256) { // Since ln(1) = 0, a value of x close to one will yield a very small result, which makes using 36 digits // worthwhile. // First, we transform x to a 36 digit fixed point value. x *= ONE_18; // We will use the following Taylor expansion, which converges very rapidly. Let z = (x - 1) / (x + 1). // ln(x) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1)) // Recall that 36 digit fixed point division requires multiplying by ONE_36, and multiplication requires // division by ONE_36. int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36); int256 z_squared = (z * z) / ONE_36; // num is the numerator of the series: the z^(2 * n + 1) term int256 num = z; // seriesSum holds the accumulated sum of each term in the series, starting with the initial z int256 seriesSum = num; // In each step, the numerator is multiplied by z^2 num = (num * z_squared) / ONE_36; seriesSum += num / 3; num = (num * z_squared) / ONE_36; seriesSum += num / 5; num = (num * z_squared) / ONE_36; seriesSum += num / 7; num = (num * z_squared) / ONE_36; seriesSum += num / 9; num = (num * z_squared) / ONE_36; seriesSum += num / 11; num = (num * z_squared) / ONE_36; seriesSum += num / 13; num = (num * z_squared) / ONE_36; seriesSum += num / 15; // 8 Taylor terms are sufficient for 36 decimal precision. // All that remains is multiplying by 2 (non fixed point). return seriesSum * 2; } }
/lib/math/Math.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow checks. * Adapted from OpenZeppelin's SafeMath library */ library Math { /** * @dev Returns the addition of two unsigned integers of 256 bits, reverting on overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; _require(c >= a, Errors.ADD_OVERFLOW); return c; } /** * @dev Returns the addition of two signed integers, reverting on overflow. */ function add(int256 a, int256 b) internal pure returns (int256) { int256 c = a + b; _require((b >= 0 && c >= a) || (b < 0 && c < a), Errors.ADD_OVERFLOW); return c; } /** * @dev Returns the subtraction of two unsigned integers of 256 bits, reverting on overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { _require(b <= a, Errors.SUB_OVERFLOW); uint256 c = a - b; return c; } /** * @dev Returns the subtraction of two signed integers, reverting on overflow. */ function sub(int256 a, int256 b) internal pure returns (int256) { int256 c = a - b; _require((b >= 0 && c <= a) || (b < 0 && c > a), Errors.SUB_OVERFLOW); return c; } /** * @dev Returns the largest of two numbers of 256 bits. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers of 256 bits. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; _require(a == 0 || c / a == b, Errors.MUL_OVERFLOW); return c; } function divDown(uint256 a, uint256 b) internal pure returns (uint256) { _require(b != 0, Errors.ZERO_DIVISION); return a / b; } function divUp(uint256 a, uint256 b) internal pure returns (uint256) { _require(b != 0, Errors.ZERO_DIVISION); if (a == 0) { return 0; } else { return 1 + (a - 1) / b; } } }
/lib/openzeppelin/Address.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { _require(address(this).balance >= amount, Errors.ADDRESS_INSUFFICIENT_BALANCE); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); _require(success, Errors.ADDRESS_CANNOT_SEND_VALUE); } }
/lib/openzeppelin/EIP712.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; /** * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data. * * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible, * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding * they need in their contracts using a combination of `abi.encode` and `keccak256`. * * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA * ({_hashTypedDataV4}). * * The implementation of the domain separator was designed to be as efficient as possible while still properly updating * the chain id to protect against replay attacks on an eventual fork of the chain. * * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask]. * * _Available since v3.4._ */ abstract contract EIP712 { /* solhint-disable var-name-mixedcase */ bytes32 private immutable _HASHED_NAME; bytes32 private immutable _HASHED_VERSION; bytes32 private immutable _TYPE_HASH; /* solhint-enable var-name-mixedcase */ /** * @dev Initializes the domain separator and parameter caches. * * The meaning of `name` and `version` is specified in * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]: * * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol. * - `version`: the current major version of the signing domain. * * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart * contract upgrade]. */ constructor(string memory name, string memory version) { _HASHED_NAME = keccak256(bytes(name)); _HASHED_VERSION = keccak256(bytes(version)); _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); } /** * @dev Returns the domain separator for the current chain. */ function _domainSeparatorV4() internal view virtual returns (bytes32) { return keccak256(abi.encode(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION, _getChainId(), address(this))); } /** * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this * function returns the hash of the fully encoded EIP712 message for this domain. * * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example: * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(address to,string contents)"), * mailTo, * keccak256(bytes(mailContents)) * ))); * address signer = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(), structHash)); } function _getChainId() private view returns (uint256 chainId) { // Silence state mutability warning without generating bytecode. // See https://github.com/ethereum/solidity/issues/10090#issuecomment-741789128 and // https://github.com/ethereum/solidity/issues/2691 this; // solhint-disable-next-line no-inline-assembly assembly { chainId := chainid() } } }
/lib/openzeppelin/EnumerableMap.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; // Based on the EnumerableMap library from OpenZeppelin contracts, altered to include the following: // * a map from IERC20 to bytes32 // * entries are stored in mappings instead of arrays, reducing implicit storage reads for out-of-bounds checks // * unchecked_at and unchecked_valueAt, which allow for more gas efficient data reads in some scenarios // * unchecked_indexOf and unchecked_setAt, which allow for more gas efficient data writes in some scenarios // // Additionally, the base private functions that work on bytes32 were removed and replaced with a native implementation // for IERC20 keys, to reduce bytecode size and runtime costs. // We're using non-standard casing for the unchecked functions to differentiate them, so we need to turn off that rule // solhint-disable func-name-mixedcase import "./IERC20.sol"; import "../helpers/BalancerErrors.sol"; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` */ library EnumerableMap { // The original OpenZeppelin implementation uses a generic Map type with bytes32 keys: this was replaced with // IERC20ToBytes32Map, which uses IERC20 keys natively, resulting in more dense bytecode. struct IERC20ToBytes32MapEntry { IERC20 _key; bytes32 _value; } struct IERC20ToBytes32Map { // Number of entries in the map uint256 _length; // Storage of map keys and values mapping(uint256 => IERC20ToBytes32MapEntry) _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping(IERC20 => uint256) _indexes; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set( IERC20ToBytes32Map storage map, IERC20 key, bytes32 value ) internal returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; // Equivalent to !contains(map, key) if (keyIndex == 0) { uint256 previousLength = map._length; map._entries[previousLength] = IERC20ToBytes32MapEntry({ _key: key, _value: value }); map._length = previousLength + 1; // The entry is stored at previousLength, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = previousLength + 1; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @dev Updates the value for an entry, given its key's index. The key index can be retrieved via * {unchecked_indexOf}, and it should be noted that key indices may change when calling {set} or {remove}. O(1). * * This function performs one less storage read than {set}, but it should only be used when `index` is known to be * within bounds. */ function unchecked_setAt( IERC20ToBytes32Map storage map, uint256 index, bytes32 value ) internal { map._entries[index]._value = value; } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(IERC20ToBytes32Map storage map, IERC20 key) internal returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; // Equivalent to contains(map, key) if (keyIndex != 0) { // To delete a key-value pair from the _entries pseudo-array in O(1), we swap the entry to delete with the // one at the highest index, and then remove this last entry (sometimes called as 'swap and pop'). // This modifies the order of the pseudo-array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._length - 1; // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. IERC20ToBytes32MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored delete map._entries[lastIndex]; map._length = lastIndex; // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function contains(IERC20ToBytes32Map storage map, IERC20 key) internal view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function length(IERC20ToBytes32Map storage map) internal view returns (uint256) { return map._length; } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(IERC20ToBytes32Map storage map, uint256 index) internal view returns (IERC20, bytes32) { _require(map._length > index, Errors.OUT_OF_BOUNDS); return unchecked_at(map, index); } /** * @dev Same as {at}, except this doesn't revert if `index` it outside of the map (i.e. if it is equal or larger * than {length}). O(1). * * This function performs one less storage read than {at}, but should only be used when `index` is known to be * within bounds. */ function unchecked_at(IERC20ToBytes32Map storage map, uint256 index) internal view returns (IERC20, bytes32) { IERC20ToBytes32MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Same as {unchecked_At}, except it only returns the value and not the key (performing one less storage * read). O(1). */ function unchecked_valueAt(IERC20ToBytes32Map storage map, uint256 index) internal view returns (bytes32) { return map._entries[index]._value; } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. Reverts with `errorCode` otherwise. */ function get( IERC20ToBytes32Map storage map, IERC20 key, uint256 errorCode ) internal view returns (bytes32) { uint256 index = map._indexes[key]; _require(index > 0, errorCode); return unchecked_valueAt(map, index - 1); } /** * @dev Returns the index for `key` **plus one**. Does not revert if the key is not in the map, and returns 0 * instead. */ function unchecked_indexOf(IERC20ToBytes32Map storage map, IERC20 key) internal view returns (uint256) { return map._indexes[key]; } }
/lib/openzeppelin/EnumerableSet.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; // Based on the EnumerableSet library from OpenZeppelin contracts, altered to remove the base private functions that // work on bytes32, replacing them with a native implementation for address values, to reduce bytecode size and runtime // costs. // The `unchecked_at` function was also added, which allows for more gas efficient data reads in some scenarios. /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // The original OpenZeppelin implementation uses a generic Set type with bytes32 values: this was replaced with // AddressSet, which uses address keys natively, resulting in more dense bytecode. struct AddressSet { // Storage of set values address[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(address => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { if (!contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. address lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { _require(set._values.length > index, Errors.OUT_OF_BOUNDS); return unchecked_at(set, index); } /** * @dev Same as {at}, except this doesn't revert if `index` it outside of the set (i.e. if it is equal or larger * than {length}). O(1). * * This function performs one less storage read than {at}, but should only be used when `index` is known to be * within bounds. */ function unchecked_at(AddressSet storage set, uint256 index) internal view returns (address) { return set._values[index]; } }
/lib/openzeppelin/IERC20.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.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); }
/lib/openzeppelin/ReentrancyGuard.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; // Based on the ReentrancyGuard library from OpenZeppelin contracts, altered to reduce bytecode size. // Modifier code is inlined by the compiler, which causes its code to appear multiple times in the codebase. By using // private functions, we achieve the same end result with slightly higher runtime gas costs but reduced bytecode size. /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { _enterNonReentrant(); _; _exitNonReentrant(); } function _enterNonReentrant() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED _require(_status != _ENTERED, Errors.REENTRANCY); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _exitNonReentrant() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } }
/lib/openzeppelin/SafeCast.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; /** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { _require(value < 2**255, Errors.SAFE_CAST_VALUE_CANT_FIT_INT256); return int256(value); } }
/lib/openzeppelin/SafeERC20.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.7.0; import "../helpers/BalancerErrors.sol"; import "./IERC20.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(address(token), abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(address(token), abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * * WARNING: `token` is assumed to be a contract: calls to EOAs will *not* revert. */ function _callOptionalReturn(address token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. (bool success, bytes memory returndata) = token.call(data); // If the low-level call didn't succeed we return whatever was returned from it. assembly { if eq(success, 0) { returndatacopy(0, 0, returndatasize()) revert(0, returndatasize()) } } // Finally we check the returndata size is either zero or true - note that this check will always pass for EOAs _require(returndata.length == 0 || abi.decode(returndata, (bool)), Errors.SAFE_ERC20_CALL_FAILED); } }
Contract ABI
[{"type":"constructor","stateMutability":"nonpayable","inputs":[{"type":"address","name":"authorizer","internalType":"contract IAuthorizer"},{"type":"address","name":"weth","internalType":"contract IWETH"},{"type":"uint256","name":"pauseWindowDuration","internalType":"uint256"},{"type":"uint256","name":"bufferPeriodDuration","internalType":"uint256"}]},{"type":"event","name":"AuthorizerChanged","inputs":[{"type":"address","name":"newAuthorizer","internalType":"contract IAuthorizer","indexed":true}],"anonymous":false},{"type":"event","name":"ExternalBalanceTransfer","inputs":[{"type":"address","name":"token","internalType":"contract IERC20","indexed":true},{"type":"address","name":"sender","internalType":"address","indexed":true},{"type":"address","name":"recipient","internalType":"address","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"FlashLoan","inputs":[{"type":"address","name":"recipient","internalType":"contract IFlashLoanRecipient","indexed":true},{"type":"address","name":"token","internalType":"contract IERC20","indexed":true},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false},{"type":"uint256","name":"feeAmount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"InternalBalanceChanged","inputs":[{"type":"address","name":"user","internalType":"address","indexed":true},{"type":"address","name":"token","internalType":"contract IERC20","indexed":true},{"type":"int256","name":"delta","internalType":"int256","indexed":false}],"anonymous":false},{"type":"event","name":"PausedStateChanged","inputs":[{"type":"bool","name":"paused","internalType":"bool","indexed":false}],"anonymous":false},{"type":"event","name":"PoolBalanceChanged","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32","indexed":true},{"type":"address","name":"liquidityProvider","internalType":"address","indexed":true},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]","indexed":false},{"type":"int256[]","name":"deltas","internalType":"int256[]","indexed":false},{"type":"uint256[]","name":"protocolFeeAmounts","internalType":"uint256[]","indexed":false}],"anonymous":false},{"type":"event","name":"PoolBalanceManaged","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32","indexed":true},{"type":"address","name":"assetManager","internalType":"address","indexed":true},{"type":"address","name":"token","internalType":"contract IERC20","indexed":true},{"type":"int256","name":"cashDelta","internalType":"int256","indexed":false},{"type":"int256","name":"managedDelta","internalType":"int256","indexed":false}],"anonymous":false},{"type":"event","name":"PoolRegistered","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32","indexed":true},{"type":"address","name":"poolAddress","internalType":"address","indexed":true},{"type":"uint8","name":"specialization","internalType":"enum IVault.PoolSpecialization","indexed":false}],"anonymous":false},{"type":"event","name":"RelayerApprovalChanged","inputs":[{"type":"address","name":"relayer","internalType":"address","indexed":true},{"type":"address","name":"sender","internalType":"address","indexed":true},{"type":"bool","name":"approved","internalType":"bool","indexed":false}],"anonymous":false},{"type":"event","name":"Swap","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32","indexed":true},{"type":"address","name":"tokenIn","internalType":"contract IERC20","indexed":true},{"type":"address","name":"tokenOut","internalType":"contract IERC20","indexed":true},{"type":"uint256","name":"amountIn","internalType":"uint256","indexed":false},{"type":"uint256","name":"amountOut","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"TokensDeregistered","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32","indexed":true},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]","indexed":false}],"anonymous":false},{"type":"event","name":"TokensRegistered","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32","indexed":true},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]","indexed":false},{"type":"address[]","name":"assetManagers","internalType":"address[]","indexed":false}],"anonymous":false},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IWETH"}],"name":"WETH","inputs":[]},{"type":"function","stateMutability":"payable","outputs":[{"type":"int256[]","name":"assetDeltas","internalType":"int256[]"}],"name":"batchSwap","inputs":[{"type":"uint8","name":"kind","internalType":"enum IVault.SwapKind"},{"type":"tuple[]","name":"swaps","internalType":"struct IVault.BatchSwapStep[]","components":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"uint256","name":"assetInIndex","internalType":"uint256"},{"type":"uint256","name":"assetOutIndex","internalType":"uint256"},{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"bytes","name":"userData","internalType":"bytes"}]},{"type":"address[]","name":"assets","internalType":"contract IAsset[]"},{"type":"tuple","name":"funds","internalType":"struct IVault.FundManagement","components":[{"type":"address","name":"sender","internalType":"address"},{"type":"bool","name":"fromInternalBalance","internalType":"bool"},{"type":"address","name":"recipient","internalType":"address payable"},{"type":"bool","name":"toInternalBalance","internalType":"bool"}]},{"type":"int256[]","name":"limits","internalType":"int256[]"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"deregisterTokens","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"exitPool","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"address","name":"sender","internalType":"address"},{"type":"address","name":"recipient","internalType":"address payable"},{"type":"tuple","name":"request","internalType":"struct IVault.ExitPoolRequest","components":[{"type":"address[]","name":"assets","internalType":"contract IAsset[]"},{"type":"uint256[]","name":"minAmountsOut","internalType":"uint256[]"},{"type":"bytes","name":"userData","internalType":"bytes"},{"type":"bool","name":"toInternalBalance","internalType":"bool"}]}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"flashLoan","inputs":[{"type":"address","name":"recipient","internalType":"contract IFlashLoanRecipient"},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]"},{"type":"uint256[]","name":"amounts","internalType":"uint256[]"},{"type":"bytes","name":"userData","internalType":"bytes"}]},{"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":"bytes32","name":"","internalType":"bytes32"}],"name":"getDomainSeparator","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256[]","name":"balances","internalType":"uint256[]"}],"name":"getInternalBalance","inputs":[{"type":"address","name":"user","internalType":"address"},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getNextNonce","inputs":[{"type":"address","name":"user","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"paused","internalType":"bool"},{"type":"uint256","name":"pauseWindowEndTime","internalType":"uint256"},{"type":"uint256","name":"bufferPeriodEndTime","internalType":"uint256"}],"name":"getPausedState","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"},{"type":"uint8","name":"","internalType":"enum IVault.PoolSpecialization"}],"name":"getPool","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"cash","internalType":"uint256"},{"type":"uint256","name":"managed","internalType":"uint256"},{"type":"uint256","name":"lastChangeBlock","internalType":"uint256"},{"type":"address","name":"assetManager","internalType":"address"}],"name":"getPoolTokenInfo","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"address","name":"token","internalType":"contract IERC20"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address[]","name":"tokens","internalType":"contract IERC20[]"},{"type":"uint256[]","name":"balances","internalType":"uint256[]"},{"type":"uint256","name":"lastChangeBlock","internalType":"uint256"}],"name":"getPoolTokens","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract ProtocolFeesCollector"}],"name":"getProtocolFeesCollector","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"hasApprovedRelayer","inputs":[{"type":"address","name":"user","internalType":"address"},{"type":"address","name":"relayer","internalType":"address"}]},{"type":"function","stateMutability":"payable","outputs":[],"name":"joinPool","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"address","name":"sender","internalType":"address"},{"type":"address","name":"recipient","internalType":"address"},{"type":"tuple","name":"request","internalType":"struct IVault.JoinPoolRequest","components":[{"type":"address[]","name":"assets","internalType":"contract IAsset[]"},{"type":"uint256[]","name":"maxAmountsIn","internalType":"uint256[]"},{"type":"bytes","name":"userData","internalType":"bytes"},{"type":"bool","name":"fromInternalBalance","internalType":"bool"}]}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"managePoolBalance","inputs":[{"type":"tuple[]","name":"ops","internalType":"struct IVault.PoolBalanceOp[]","components":[{"type":"uint8","name":"kind","internalType":"enum IVault.PoolBalanceOpKind"},{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"address","name":"token","internalType":"contract IERC20"},{"type":"uint256","name":"amount","internalType":"uint256"}]}]},{"type":"function","stateMutability":"payable","outputs":[],"name":"manageUserBalance","inputs":[{"type":"tuple[]","name":"ops","internalType":"struct IVault.UserBalanceOp[]","components":[{"type":"uint8","name":"kind","internalType":"enum IVault.UserBalanceOpKind"},{"type":"address","name":"asset","internalType":"contract IAsset"},{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"address","name":"sender","internalType":"address"},{"type":"address","name":"recipient","internalType":"address payable"}]}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"int256[]","name":"","internalType":"int256[]"}],"name":"queryBatchSwap","inputs":[{"type":"uint8","name":"kind","internalType":"enum IVault.SwapKind"},{"type":"tuple[]","name":"swaps","internalType":"struct IVault.BatchSwapStep[]","components":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"uint256","name":"assetInIndex","internalType":"uint256"},{"type":"uint256","name":"assetOutIndex","internalType":"uint256"},{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"bytes","name":"userData","internalType":"bytes"}]},{"type":"address[]","name":"assets","internalType":"contract IAsset[]"},{"type":"tuple","name":"funds","internalType":"struct IVault.FundManagement","components":[{"type":"address","name":"sender","internalType":"address"},{"type":"bool","name":"fromInternalBalance","internalType":"bool"},{"type":"address","name":"recipient","internalType":"address payable"},{"type":"bool","name":"toInternalBalance","internalType":"bool"}]}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"registerPool","inputs":[{"type":"uint8","name":"specialization","internalType":"enum IVault.PoolSpecialization"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"registerTokens","inputs":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"address[]","name":"tokens","internalType":"contract IERC20[]"},{"type":"address[]","name":"assetManagers","internalType":"address[]"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setAuthorizer","inputs":[{"type":"address","name":"newAuthorizer","internalType":"contract IAuthorizer"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setPaused","inputs":[{"type":"bool","name":"paused","internalType":"bool"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setRelayerApproval","inputs":[{"type":"address","name":"sender","internalType":"address"},{"type":"address","name":"relayer","internalType":"address"},{"type":"bool","name":"approved","internalType":"bool"}]},{"type":"function","stateMutability":"payable","outputs":[{"type":"uint256","name":"amountCalculated","internalType":"uint256"}],"name":"swap","inputs":[{"type":"tuple","name":"singleSwap","internalType":"struct IVault.SingleSwap","components":[{"type":"bytes32","name":"poolId","internalType":"bytes32"},{"type":"uint8","name":"kind","internalType":"enum IVault.SwapKind"},{"type":"address","name":"assetIn","internalType":"contract IAsset"},{"type":"address","name":"assetOut","internalType":"contract IAsset"},{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"bytes","name":"userData","internalType":"bytes"}]},{"type":"tuple","name":"funds","internalType":"struct IVault.FundManagement","components":[{"type":"address","name":"sender","internalType":"address"},{"type":"bool","name":"fromInternalBalance","internalType":"bool"},{"type":"address","name":"recipient","internalType":"address payable"},{"type":"bool","name":"toInternalBalance","internalType":"bool"}]},{"type":"uint256","name":"limit","internalType":"uint256"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"receive","stateMutability":"payable"}]
Contract Creation Code
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
Deployed ByteCode
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