Polygon Sponsored slots available. Book your slot here!
Overview
MATIC Balance
0 MATIC
MATIC Value
$0.00More Info
Private Name Tags
ContractCreator:
Sponsored
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60c06040 | 31464988 | 603 days ago | IN | Create: AllowedAdaptersPerManagerPolicy | 0 MATIC | 0.05369097 |
Loading...
Loading
Contract Name:
AllowedAdaptersPerManagerPolicy
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import "../../../../core/fund/comptroller/ComptrollerLib.sol"; import "../../../../core/fund/vault/VaultLib.sol"; import "../utils/AddressListRegistryPerUserPolicyBase.sol"; /// @title AllowedAdaptersPerManagerPolicy Contract /// @author Enzyme Council <[email protected]> /// @notice A policy that limits which adapters an asset manager can use for a given fund contract AllowedAdaptersPerManagerPolicy is AddressListRegistryPerUserPolicyBase { uint256 public constant BYPASS_FLAG = type(uint256).max; constructor(address _policyManager, address _addressListRegistry) public AddressListRegistryPerUserPolicyBase(_policyManager, _addressListRegistry) {} // EXTERNAL FUNCTIONS /// @notice Whether or not the policy can be disabled /// @return canDisable_ True if the policy can be disabled function canDisable() external pure virtual override returns (bool canDisable_) { return true; } /// @notice Provides a constant string identifier for a policy /// @return identifier_ The identifer string function identifier() external pure override returns (string memory identifier_) { return "ALLOWED_ADAPTERS_PER_MANAGER"; } /// @notice Gets the implemented PolicyHooks for a policy /// @return implementedHooks_ The implemented PolicyHooks function implementedHooks() external pure override returns (IPolicyManager.PolicyHook[] memory implementedHooks_) { implementedHooks_ = new IPolicyManager.PolicyHook[](1); implementedHooks_[0] = IPolicyManager.PolicyHook.PostCallOnIntegration; return implementedHooks_; } /// @notice Updates the policy settings for a fund /// @param _comptrollerProxy The fund's ComptrollerProxy address /// @param _encodedSettings Encoded settings to apply to a fund /// @dev Assigns a new array of lists (does not add/remove lists nor update items in a list) function updateFundSettings(address _comptrollerProxy, bytes calldata _encodedSettings) external override onlyPolicyManager { __updateListsForFund(_comptrollerProxy, _encodedSettings); } /// @notice Apply the rule with the specified parameters of a PolicyHook /// @param _comptrollerProxy The fund's ComptrollerProxy address /// @param _encodedArgs Encoded args with which to validate the rule /// @return isValid_ True if the rule passes /// @dev onlyPolicyManager validation not necessary, as state is not updated and no events are fired function validateRule( address _comptrollerProxy, IPolicyManager.PolicyHook, bytes calldata _encodedArgs ) external override returns (bool isValid_) { (address caller, address adapter, , , , , ) = __decodePostCallOnIntegrationValidationData( _encodedArgs ); return passesRule(_comptrollerProxy, caller, adapter); } // PUBLIC FUNCTIONS /// @notice Checks whether a particular condition passes the rule for a particular fund /// @param _comptrollerProxy The fund's ComptrollerProxy address /// @param _caller The caller for which to check the rule /// @param _adapter The adapter for which to check the rule /// @return isValid_ True if the rule passes function passesRule( address _comptrollerProxy, address _caller, address _adapter ) public view returns (bool isValid_) { if ( _caller == VaultLib(payable(ComptrollerLib(_comptrollerProxy).getVaultProxy())).getOwner() ) { // fund owner passes rule by default return true; } uint256[] memory listIds = getListIdsForFundAndUser(_comptrollerProxy, _caller); if (listIds.length == 0) { // A manager without any configured lists does not pass the rule return false; } if (listIds[0] == BYPASS_FLAG) { // The bypass flag is only accepted if in the first position in listIds return true; } return ADDRESS_LIST_REGISTRY_CONTRACT.isInSomeOfLists(listIds, _adapter); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../../utils/Context.sol"; import "./IERC20.sol"; import "../../math/SafeMath.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal virtual { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../../utils/Context.sol"; import "./ERC20.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { using SafeMath for uint256; /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.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); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "./IERC20.sol"; import "../../math/SafeMath.sol"; import "../../utils/Address.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 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @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). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 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. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @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, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import "../dispatcher/IDispatcher.sol"; /// @title AddressListRegistry Contract /// @author Enzyme Council <[email protected]> /// @notice A contract for creating and updating lists of addresses contract AddressListRegistry { enum UpdateType {None, AddOnly, RemoveOnly, AddAndRemove} event ItemAddedToList(uint256 indexed id, address item); event ItemRemovedFromList(uint256 indexed id, address item); event ListAttested(uint256 indexed id, string description); event ListCreated( address indexed creator, address indexed owner, uint256 id, UpdateType updateType ); event ListOwnerSet(uint256 indexed id, address indexed nextOwner); event ListUpdateTypeSet( uint256 indexed id, UpdateType prevUpdateType, UpdateType indexed nextUpdateType ); struct ListInfo { address owner; UpdateType updateType; mapping(address => bool) itemToIsInList; } address private immutable DISPATCHER; ListInfo[] private lists; modifier onlyListOwner(uint256 _id) { require(__isListOwner(msg.sender, _id), "Only callable by list owner"); _; } constructor(address _dispatcher) public { DISPATCHER = _dispatcher; // Create the first list as completely empty and immutable, to protect the default `id` lists.push(ListInfo({owner: address(0), updateType: UpdateType.None})); } // EXTERNAL FUNCTIONS /// @notice Adds items to a given list /// @param _id The id of the list /// @param _items The items to add to the list function addToList(uint256 _id, address[] calldata _items) external onlyListOwner(_id) { UpdateType updateType = getListUpdateType(_id); require( updateType == UpdateType.AddOnly || updateType == UpdateType.AddAndRemove, "addToList: Cannot add to list" ); __addToList(_id, _items); } /// @notice Attests active ownership for lists and (optionally) a description of each list's content /// @param _ids The ids of the lists /// @param _descriptions The descriptions of the lists' content /// @dev Since UserA can create a list on behalf of UserB, this function provides a mechanism /// for UserB to attest to their management of the items therein. It will not be visible /// on-chain, but will be available in event logs. function attestLists(uint256[] calldata _ids, string[] calldata _descriptions) external { require(_ids.length == _descriptions.length, "attestLists: Unequal arrays"); for (uint256 i; i < _ids.length; i++) { require( __isListOwner(msg.sender, _ids[i]), "attestLists: Only callable by list owner" ); emit ListAttested(_ids[i], _descriptions[i]); } } /// @notice Creates a new list /// @param _owner The owner of the list /// @param _updateType The UpdateType for the list /// @param _initialItems The initial items to add to the list /// @return id_ The id of the newly-created list /// @dev Specify the DISPATCHER as the _owner to make the Enzyme Council the owner function createList( address _owner, UpdateType _updateType, address[] calldata _initialItems ) external returns (uint256 id_) { id_ = getListCount(); lists.push(ListInfo({owner: _owner, updateType: _updateType})); emit ListCreated(msg.sender, _owner, id_, _updateType); __addToList(id_, _initialItems); return id_; } /// @notice Removes items from a given list /// @param _id The id of the list /// @param _items The items to remove from the list function removeFromList(uint256 _id, address[] calldata _items) external onlyListOwner(_id) { UpdateType updateType = getListUpdateType(_id); require( updateType == UpdateType.RemoveOnly || updateType == UpdateType.AddAndRemove, "removeFromList: Cannot remove from list" ); // Silently ignores items that are not in the list for (uint256 i; i < _items.length; i++) { if (isInList(_id, _items[i])) { lists[_id].itemToIsInList[_items[i]] = false; emit ItemRemovedFromList(_id, _items[i]); } } } /// @notice Sets the owner for a given list /// @param _id The id of the list /// @param _nextOwner The owner to set function setListOwner(uint256 _id, address _nextOwner) external onlyListOwner(_id) { lists[_id].owner = _nextOwner; emit ListOwnerSet(_id, _nextOwner); } /// @notice Sets the UpdateType for a given list /// @param _id The id of the list /// @param _nextUpdateType The UpdateType to set /// @dev Can only change to a less mutable option (e.g., both add and remove => add only) function setListUpdateType(uint256 _id, UpdateType _nextUpdateType) external onlyListOwner(_id) { UpdateType prevUpdateType = getListUpdateType(_id); require( _nextUpdateType == UpdateType.None || prevUpdateType == UpdateType.AddAndRemove, "setListUpdateType: _nextUpdateType not allowed" ); lists[_id].updateType = _nextUpdateType; emit ListUpdateTypeSet(_id, prevUpdateType, _nextUpdateType); } // PRIVATE FUNCTIONS /// @dev Helper to add items to a list function __addToList(uint256 _id, address[] memory _items) private { for (uint256 i; i < _items.length; i++) { if (!isInList(_id, _items[i])) { lists[_id].itemToIsInList[_items[i]] = true; emit ItemAddedToList(_id, _items[i]); } } } /// @dev Helper to check if an account is the owner of a given list function __isListOwner(address _who, uint256 _id) private view returns (bool isListOwner_) { address owner = getListOwner(_id); return _who == owner || (owner == getDispatcher() && _who == IDispatcher(getDispatcher()).getOwner()); } ///////////////// // LIST SEARCH // ///////////////// // These functions are concerned with exiting quickly and do not consider empty params. // Developers should sanitize empty params as necessary for their own use cases. // EXTERNAL FUNCTIONS // Multiple items, single list /// @notice Checks if multiple items are all in a given list /// @param _id The list id /// @param _items The items to check /// @return areAllInList_ True if all items are in the list function areAllInList(uint256 _id, address[] memory _items) external view returns (bool areAllInList_) { for (uint256 i; i < _items.length; i++) { if (!isInList(_id, _items[i])) { return false; } } return true; } /// @notice Checks if multiple items are all absent from a given list /// @param _id The list id /// @param _items The items to check /// @return areAllNotInList_ True if no items are in the list function areAllNotInList(uint256 _id, address[] memory _items) external view returns (bool areAllNotInList_) { for (uint256 i; i < _items.length; i++) { if (isInList(_id, _items[i])) { return false; } } return true; } // Multiple items, multiple lists /// @notice Checks if multiple items are all in all of a given set of lists /// @param _ids The list ids /// @param _items The items to check /// @return areAllInAllLists_ True if all items are in all of the lists function areAllInAllLists(uint256[] memory _ids, address[] memory _items) external view returns (bool areAllInAllLists_) { for (uint256 i; i < _items.length; i++) { if (!isInAllLists(_ids, _items[i])) { return false; } } return true; } /// @notice Checks if multiple items are all in one of a given set of lists /// @param _ids The list ids /// @param _items The items to check /// @return areAllInSomeOfLists_ True if all items are in one of the lists function areAllInSomeOfLists(uint256[] memory _ids, address[] memory _items) external view returns (bool areAllInSomeOfLists_) { for (uint256 i; i < _items.length; i++) { if (!isInSomeOfLists(_ids, _items[i])) { return false; } } return true; } /// @notice Checks if multiple items are all absent from all of a given set of lists /// @param _ids The list ids /// @param _items The items to check /// @return areAllNotInAnyOfLists_ True if all items are absent from all lists function areAllNotInAnyOfLists(uint256[] memory _ids, address[] memory _items) external view returns (bool areAllNotInAnyOfLists_) { for (uint256 i; i < _items.length; i++) { if (isInSomeOfLists(_ids, _items[i])) { return false; } } return true; } // PUBLIC FUNCTIONS // Single item, multiple lists /// @notice Checks if an item is in all of a given set of lists /// @param _ids The list ids /// @param _item The item to check /// @return isInAllLists_ True if item is in all of the lists function isInAllLists(uint256[] memory _ids, address _item) public view returns (bool isInAllLists_) { for (uint256 i; i < _ids.length; i++) { if (!isInList(_ids[i], _item)) { return false; } } return true; } /// @notice Checks if an item is in at least one of a given set of lists /// @param _ids The list ids /// @param _item The item to check /// @return isInSomeOfLists_ True if item is in one of the lists function isInSomeOfLists(uint256[] memory _ids, address _item) public view returns (bool isInSomeOfLists_) { for (uint256 i; i < _ids.length; i++) { if (isInList(_ids[i], _item)) { return true; } } return false; } /////////////////// // STATE GETTERS // /////////////////// /// @notice Gets the `DISPATCHER` variable /// @return dispatcher_ The `DISPATCHER` variable value function getDispatcher() public view returns (address dispatcher_) { return DISPATCHER; } /// @notice Gets the total count of lists /// @return count_ The total count function getListCount() public view returns (uint256 count_) { return lists.length; } /// @notice Gets the owner of a given list /// @param _id The list id /// @return owner_ The owner function getListOwner(uint256 _id) public view returns (address owner_) { return lists[_id].owner; } /// @notice Gets the UpdateType of a given list /// @param _id The list id /// @return updateType_ The UpdateType function getListUpdateType(uint256 _id) public view returns (UpdateType updateType_) { return lists[_id].updateType; } /// @notice Checks if an item is in a given list /// @param _id The list id /// @param _item The item to check /// @return isInList_ True if the item is in the list function isInList(uint256 _id, address _item) public view returns (bool isInList_) { return lists[_id].itemToIsInList[_item]; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IDispatcher Interface /// @author Enzyme Council <[email protected]> interface IDispatcher { function cancelMigration(address _vaultProxy, bool _bypassFailure) external; function claimOwnership() external; function deployVaultProxy( address _vaultLib, address _owner, address _vaultAccessor, string calldata _fundName ) external returns (address vaultProxy_); function executeMigration(address _vaultProxy, bool _bypassFailure) external; function getCurrentFundDeployer() external view returns (address currentFundDeployer_); function getFundDeployerForVaultProxy(address _vaultProxy) external view returns (address fundDeployer_); function getMigrationRequestDetailsForVaultProxy(address _vaultProxy) external view returns ( address nextFundDeployer_, address nextVaultAccessor_, address nextVaultLib_, uint256 executableTimestamp_ ); function getMigrationTimelock() external view returns (uint256 migrationTimelock_); function getNominatedOwner() external view returns (address nominatedOwner_); function getOwner() external view returns (address owner_); function getSharesTokenSymbol() external view returns (string memory sharesTokenSymbol_); function getTimelockRemainingForMigrationRequest(address _vaultProxy) external view returns (uint256 secondsRemaining_); function hasExecutableMigrationRequest(address _vaultProxy) external view returns (bool hasExecutableRequest_); function hasMigrationRequest(address _vaultProxy) external view returns (bool hasMigrationRequest_); function removeNominatedOwner() external; function setCurrentFundDeployer(address _nextFundDeployer) external; function setMigrationTimelock(uint256 _nextTimelock) external; function setNominatedOwner(address _nextNominatedOwner) external; function setSharesTokenSymbol(string calldata _nextSymbol) external; function signalMigration( address _vaultProxy, address _nextVaultAccessor, address _nextVaultLib, bool _bypassFailure ) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IExternalPosition Contract /// @author Enzyme Council <[email protected]> interface IExternalPosition { function getDebtAssets() external returns (address[] memory, uint256[] memory); function getManagedAssets() external returns (address[] memory, uint256[] memory); function init(bytes memory) external; function receiveCallFromVault(bytes memory) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IProtocolFeeReserve1 Interface /// @author Enzyme Council <[email protected]> /// @dev Each interface should inherit the previous interface, /// e.g., `IProtocolFeeReserve2 is IProtocolFeeReserve1` interface IProtocolFeeReserve1 { function buyBackSharesViaTrustedVaultProxy( uint256 _sharesAmount, uint256 _mlnValue, uint256 _gav ) external returns (uint256 mlnAmountToBurn_); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "./VaultLibBaseCore.sol"; /// @title VaultLibBase1 Contract /// @author Enzyme Council <[email protected]> /// @notice The first implementation of VaultLibBaseCore, with additional events and storage /// @dev All subsequent implementations should inherit the previous implementation, /// e.g., `VaultLibBase2 is VaultLibBase1` /// DO NOT EDIT CONTRACT. abstract contract VaultLibBase1 is VaultLibBaseCore { event AssetWithdrawn(address indexed asset, address indexed target, uint256 amount); event TrackedAssetAdded(address asset); event TrackedAssetRemoved(address asset); address[] internal trackedAssets; mapping(address => bool) internal assetToIsTracked; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "./VaultLibBase1.sol"; /// @title VaultLibBase2 Contract /// @author Enzyme Council <[email protected]> /// @notice The first implementation of VaultLibBase1, with additional events and storage /// @dev All subsequent implementations should inherit the previous implementation, /// e.g., `VaultLibBase2 is VaultLibBase1` /// DO NOT EDIT CONTRACT. abstract contract VaultLibBase2 is VaultLibBase1 { event AssetManagerAdded(address manager); event AssetManagerRemoved(address manager); event EthReceived(address indexed sender, uint256 amount); event ExternalPositionAdded(address indexed externalPosition); event ExternalPositionRemoved(address indexed externalPosition); event FreelyTransferableSharesSet(); event NameSet(string name); event NominatedOwnerRemoved(address indexed nominatedOwner); event NominatedOwnerSet(address indexed nominatedOwner); event ProtocolFeePaidInShares(uint256 sharesAmount); event ProtocolFeeSharesBoughtBack(uint256 sharesAmount, uint256 mlnValue, uint256 mlnBurned); event OwnershipTransferred(address indexed prevOwner, address indexed nextOwner); event SymbolSet(string symbol); // In order to make transferability guarantees to liquidity pools and other smart contracts // that hold/treat shares as generic ERC20 tokens, a permanent guarantee on transferability // is required. Once set as `true`, freelyTransferableShares should never be unset. bool internal freelyTransferableShares; address internal nominatedOwner; address[] internal activeExternalPositions; mapping(address => bool) internal accountToIsAssetManager; mapping(address => bool) internal externalPositionToIsActive; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "./interfaces/IMigratableVault.sol"; import "./utils/ProxiableVaultLib.sol"; import "./utils/SharesTokenBase.sol"; /// @title VaultLibBaseCore Contract /// @author Enzyme Council <[email protected]> /// @notice A persistent contract containing all required storage variables and /// required functions for a VaultLib implementation /// @dev DO NOT EDIT CONTRACT. If new events or storage are necessary, they should be added to /// a numbered VaultLibBaseXXX that inherits the previous base. See VaultLibBase1. abstract contract VaultLibBaseCore is IMigratableVault, ProxiableVaultLib, SharesTokenBase { event AccessorSet(address prevAccessor, address nextAccessor); event MigratorSet(address prevMigrator, address nextMigrator); event OwnerSet(address prevOwner, address nextOwner); event VaultLibSet(address prevVaultLib, address nextVaultLib); address internal accessor; address internal creator; address internal migrator; address internal owner; // EXTERNAL FUNCTIONS /// @notice Initializes the VaultProxy with core configuration /// @param _owner The address to set as the fund owner /// @param _accessor The address to set as the permissioned accessor of the VaultLib /// @param _fundName The name of the fund /// @dev Serves as a per-proxy pseudo-constructor function init( address _owner, address _accessor, string calldata _fundName ) external override { require(creator == address(0), "init: Proxy already initialized"); creator = msg.sender; sharesName = _fundName; __setAccessor(_accessor); __setOwner(_owner); emit VaultLibSet(address(0), getVaultLib()); } /// @notice Sets the permissioned accessor of the VaultLib /// @param _nextAccessor The address to set as the permissioned accessor of the VaultLib function setAccessor(address _nextAccessor) external override { require(msg.sender == creator, "setAccessor: Only callable by the contract creator"); __setAccessor(_nextAccessor); } /// @notice Sets the VaultLib target for the VaultProxy /// @param _nextVaultLib The address to set as the VaultLib /// @dev This function is absolutely critical. __updateCodeAddress() validates that the /// target is a valid Proxiable contract instance. /// Does not block _nextVaultLib from being the same as the current VaultLib function setVaultLib(address _nextVaultLib) external override { require(msg.sender == creator, "setVaultLib: Only callable by the contract creator"); address prevVaultLib = getVaultLib(); __updateCodeAddress(_nextVaultLib); emit VaultLibSet(prevVaultLib, _nextVaultLib); } // PUBLIC FUNCTIONS /// @notice Checks whether an account is allowed to migrate the VaultProxy /// @param _who The account to check /// @return canMigrate_ True if the account is allowed to migrate the VaultProxy function canMigrate(address _who) public view virtual override returns (bool canMigrate_) { return _who == owner || _who == migrator; } /// @notice Gets the VaultLib target for the VaultProxy /// @return vaultLib_ The address of the VaultLib target function getVaultLib() public view returns (address vaultLib_) { assembly { // solium-disable-line vaultLib_ := sload(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc) } return vaultLib_; } // INTERNAL FUNCTIONS /// @dev Helper to set the permissioned accessor of the VaultProxy. /// Does not prevent the prevAccessor from being the _nextAccessor. function __setAccessor(address _nextAccessor) internal { require(_nextAccessor != address(0), "__setAccessor: _nextAccessor cannot be empty"); address prevAccessor = accessor; accessor = _nextAccessor; emit AccessorSet(prevAccessor, _nextAccessor); } /// @dev Helper to set the owner of the VaultProxy function __setOwner(address _nextOwner) internal { require(_nextOwner != address(0), "__setOwner: _nextOwner cannot be empty"); address prevOwner = owner; require(_nextOwner != prevOwner, "__setOwner: _nextOwner is the current owner"); owner = _nextOwner; emit OwnerSet(prevOwner, _nextOwner); } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IExternalPositionVault interface /// @author Enzyme Council <[email protected]> /// Provides an interface to get the externalPositionLib for a given type from the Vault interface IExternalPositionVault { function getExternalPositionLibForType(uint256) external view returns (address); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IFreelyTransferableSharesVault Interface /// @author Enzyme Council <[email protected]> /// @notice Provides the interface for determining whether a vault's shares /// are guaranteed to be freely transferable. /// @dev DO NOT EDIT CONTRACT interface IFreelyTransferableSharesVault { function sharesAreFreelyTransferable() external view returns (bool sharesAreFreelyTransferable_); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IMigratableVault Interface /// @author Enzyme Council <[email protected]> /// @dev DO NOT EDIT CONTRACT interface IMigratableVault { function canMigrate(address _who) external view returns (bool canMigrate_); function init( address _owner, address _accessor, string calldata _fundName ) external; function setAccessor(address _nextAccessor) external; function setVaultLib(address _nextVaultLib) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title ProxiableVaultLib Contract /// @author Enzyme Council <[email protected]> /// @notice A contract that defines the upgrade behavior for VaultLib instances /// @dev The recommended implementation of the target of a proxy according to EIP-1822 and EIP-1967 /// Code position in storage is `bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)`, /// which is "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc". abstract contract ProxiableVaultLib { /// @dev Updates the target of the proxy to be the contract at _nextVaultLib function __updateCodeAddress(address _nextVaultLib) internal { require( bytes32(0x027b9570e9fedc1a80b937ae9a06861e5faef3992491af30b684a64b3fbec7a5) == ProxiableVaultLib(_nextVaultLib).proxiableUUID(), "__updateCodeAddress: _nextVaultLib not compatible" ); assembly { // solium-disable-line sstore( 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, _nextVaultLib ) } } /// @notice Returns a unique bytes32 hash for VaultLib instances /// @return uuid_ The bytes32 hash representing the UUID /// @dev The UUID is `bytes32(keccak256('mln.proxiable.vaultlib'))` function proxiableUUID() public pure returns (bytes32 uuid_) { return 0x027b9570e9fedc1a80b937ae9a06861e5faef3992491af30b684a64b3fbec7a5; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "./VaultLibSafeMath.sol"; /// @title StandardERC20 Contract /// @author Enzyme Council <[email protected]> /// @notice Contains the storage, events, and default logic of an ERC20-compliant contract. /// @dev The logic can be overridden by VaultLib implementations. /// Adapted from OpenZeppelin 3.2.0. /// DO NOT EDIT THIS CONTRACT. abstract contract SharesTokenBase { using VaultLibSafeMath for uint256; event Approval(address indexed owner, address indexed spender, uint256 value); event Transfer(address indexed from, address indexed to, uint256 value); string internal sharesName; string internal sharesSymbol; uint256 internal sharesTotalSupply; mapping(address => uint256) internal sharesBalances; mapping(address => mapping(address => uint256)) internal sharesAllowances; // EXTERNAL FUNCTIONS /// @dev Standard implementation of ERC20's approve(). Can be overridden. function approve(address _spender, uint256 _amount) public virtual returns (bool) { __approve(msg.sender, _spender, _amount); return true; } /// @dev Standard implementation of ERC20's transfer(). Can be overridden. function transfer(address _recipient, uint256 _amount) public virtual returns (bool) { __transfer(msg.sender, _recipient, _amount); return true; } /// @dev Standard implementation of ERC20's transferFrom(). Can be overridden. function transferFrom( address _sender, address _recipient, uint256 _amount ) public virtual returns (bool) { __transfer(_sender, _recipient, _amount); __approve( _sender, msg.sender, sharesAllowances[_sender][msg.sender].sub( _amount, "ERC20: transfer amount exceeds allowance" ) ); return true; } // EXTERNAL FUNCTIONS - VIEW /// @dev Standard implementation of ERC20's allowance(). Can be overridden. function allowance(address _owner, address _spender) public view virtual returns (uint256) { return sharesAllowances[_owner][_spender]; } /// @dev Standard implementation of ERC20's balanceOf(). Can be overridden. function balanceOf(address _account) public view virtual returns (uint256) { return sharesBalances[_account]; } /// @dev Standard implementation of ERC20's decimals(). Can not be overridden. function decimals() public pure returns (uint8) { return 18; } /// @dev Standard implementation of ERC20's name(). Can be overridden. function name() public view virtual returns (string memory) { return sharesName; } /// @dev Standard implementation of ERC20's symbol(). Can be overridden. function symbol() public view virtual returns (string memory) { return sharesSymbol; } /// @dev Standard implementation of ERC20's totalSupply(). Can be overridden. function totalSupply() public view virtual returns (uint256) { return sharesTotalSupply; } // INTERNAL FUNCTIONS /// @dev Helper for approve(). Can be overridden. function __approve( address _owner, address _spender, uint256 _amount ) internal virtual { require(_owner != address(0), "ERC20: approve from the zero address"); require(_spender != address(0), "ERC20: approve to the zero address"); sharesAllowances[_owner][_spender] = _amount; emit Approval(_owner, _spender, _amount); } /// @dev Helper to burn tokens from an account. Can be overridden. function __burn(address _account, uint256 _amount) internal virtual { require(_account != address(0), "ERC20: burn from the zero address"); sharesBalances[_account] = sharesBalances[_account].sub( _amount, "ERC20: burn amount exceeds balance" ); sharesTotalSupply = sharesTotalSupply.sub(_amount); emit Transfer(_account, address(0), _amount); } /// @dev Helper to mint tokens to an account. Can be overridden. function __mint(address _account, uint256 _amount) internal virtual { require(_account != address(0), "ERC20: mint to the zero address"); sharesTotalSupply = sharesTotalSupply.add(_amount); sharesBalances[_account] = sharesBalances[_account].add(_amount); emit Transfer(address(0), _account, _amount); } /// @dev Helper to transfer tokens between accounts. Can be overridden. function __transfer( address _sender, address _recipient, uint256 _amount ) internal virtual { require(_sender != address(0), "ERC20: transfer from the zero address"); require(_recipient != address(0), "ERC20: transfer to the zero address"); sharesBalances[_sender] = sharesBalances[_sender].sub( _amount, "ERC20: transfer amount exceeds balance" ); sharesBalances[_recipient] = sharesBalances[_recipient].add(_amount); emit Transfer(_sender, _recipient, _amount); } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title VaultLibSafeMath library /// @notice A narrowed, verbatim implementation of OpenZeppelin 3.2.0 SafeMath /// for use with VaultLib /// @dev Preferred to importing from npm to guarantee consistent logic and revert reasons /// between VaultLib implementations /// DO NOT EDIT THIS CONTRACT library VaultLibSafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "VaultLibSafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "VaultLibSafeMath: subtraction overflow"); } function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "VaultLibSafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "VaultLibSafeMath: division by zero"); } function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "VaultLibSafeMath: modulo by zero"); } function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IFundDeployer Interface /// @author Enzyme Council <[email protected]> interface IFundDeployer { function getOwner() external view returns (address); function hasReconfigurationRequest(address) external view returns (bool); function isAllowedBuySharesOnBehalfCaller(address) external view returns (bool); function isAllowedVaultCall( address, bytes4, bytes32 ) external view returns (bool); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "@openzeppelin/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; import "../../../../persistent/dispatcher/IDispatcher.sol"; import "../../../../persistent/external-positions/IExternalPosition.sol"; import "../../../extensions/IExtension.sol"; import "../../../extensions/fee-manager/IFeeManager.sol"; import "../../../extensions/policy-manager/IPolicyManager.sol"; import "../../../infrastructure/gas-relayer/GasRelayRecipientMixin.sol"; import "../../../infrastructure/gas-relayer/IGasRelayPaymaster.sol"; import "../../../infrastructure/gas-relayer/IGasRelayPaymasterDepositor.sol"; import "../../../infrastructure/value-interpreter/IValueInterpreter.sol"; import "../../../utils/beacon-proxy/IBeaconProxyFactory.sol"; import "../../../utils/AddressArrayLib.sol"; import "../../fund-deployer/IFundDeployer.sol"; import "../vault/IVault.sol"; import "./IComptroller.sol"; /// @title ComptrollerLib Contract /// @author Enzyme Council <[email protected]> /// @notice The core logic library shared by all funds contract ComptrollerLib is IComptroller, IGasRelayPaymasterDepositor, GasRelayRecipientMixin { using AddressArrayLib for address[]; using SafeMath for uint256; using SafeERC20 for ERC20; event AutoProtocolFeeSharesBuybackSet(bool autoProtocolFeeSharesBuyback); event BuyBackMaxProtocolFeeSharesFailed( bytes indexed failureReturnData, uint256 sharesAmount, uint256 buybackValueInMln, uint256 gav ); event DeactivateFeeManagerFailed(); event GasRelayPaymasterSet(address gasRelayPaymaster); event MigratedSharesDuePaid(uint256 sharesDue); event PayProtocolFeeDuringDestructFailed(); event PreRedeemSharesHookFailed( bytes indexed failureReturnData, address indexed redeemer, uint256 sharesAmount ); event RedeemSharesInKindCalcGavFailed(); event SharesBought( address indexed buyer, uint256 investmentAmount, uint256 sharesIssued, uint256 sharesReceived ); event SharesRedeemed( address indexed redeemer, address indexed recipient, uint256 sharesAmount, address[] receivedAssets, uint256[] receivedAssetAmounts ); event VaultProxySet(address vaultProxy); // Constants and immutables - shared by all proxies uint256 private constant ONE_HUNDRED_PERCENT = 10000; uint256 private constant SHARES_UNIT = 10**18; address private constant SPECIFIC_ASSET_REDEMPTION_DUMMY_FORFEIT_ADDRESS = 0x000000000000000000000000000000000000aaaa; address private immutable DISPATCHER; address private immutable EXTERNAL_POSITION_MANAGER; address private immutable FUND_DEPLOYER; address private immutable FEE_MANAGER; address private immutable INTEGRATION_MANAGER; address private immutable MLN_TOKEN; address private immutable POLICY_MANAGER; address private immutable PROTOCOL_FEE_RESERVE; address private immutable VALUE_INTERPRETER; address private immutable WETH_TOKEN; // Pseudo-constants (can only be set once) address internal denominationAsset; address internal vaultProxy; // True only for the one non-proxy bool internal isLib; // Storage // Attempts to buy back protocol fee shares immediately after collection bool internal autoProtocolFeeSharesBuyback; // A reverse-mutex, granting atomic permission for particular contracts to make vault calls bool internal permissionedVaultActionAllowed; // A mutex to protect against reentrancy bool internal reentranceLocked; // A timelock after the last time shares were bought for an account // that must expire before that account transfers or redeems their shares uint256 internal sharesActionTimelock; mapping(address => uint256) internal acctToLastSharesBoughtTimestamp; // The contract which manages paying gas relayers address private gasRelayPaymaster; /////////////// // MODIFIERS // /////////////// modifier allowsPermissionedVaultAction { __assertPermissionedVaultActionNotAllowed(); permissionedVaultActionAllowed = true; _; permissionedVaultActionAllowed = false; } modifier locksReentrance() { __assertNotReentranceLocked(); reentranceLocked = true; _; reentranceLocked = false; } modifier onlyFundDeployer() { __assertIsFundDeployer(); _; } modifier onlyGasRelayPaymaster() { __assertIsGasRelayPaymaster(); _; } modifier onlyOwner() { __assertIsOwner(__msgSender()); _; } modifier onlyOwnerNotRelayable() { __assertIsOwner(msg.sender); _; } // ASSERTION HELPERS // Modifiers are inefficient in terms of contract size, // so we use helper functions to prevent repetitive inlining of expensive string values. function __assertIsFundDeployer() private view { require(msg.sender == getFundDeployer(), "Only FundDeployer callable"); } function __assertIsGasRelayPaymaster() private view { require(msg.sender == getGasRelayPaymaster(), "Only Gas Relay Paymaster callable"); } function __assertIsOwner(address _who) private view { require(_who == IVault(getVaultProxy()).getOwner(), "Only fund owner callable"); } function __assertNotReentranceLocked() private view { require(!reentranceLocked, "Re-entrance"); } function __assertPermissionedVaultActionNotAllowed() private view { require(!permissionedVaultActionAllowed, "Vault action re-entrance"); } function __assertSharesActionNotTimelocked(address _vaultProxy, address _account) private view { uint256 lastSharesBoughtTimestamp = getLastSharesBoughtTimestampForAccount(_account); require( lastSharesBoughtTimestamp == 0 || block.timestamp.sub(lastSharesBoughtTimestamp) >= getSharesActionTimelock() || __hasPendingMigrationOrReconfiguration(_vaultProxy), "Shares action timelocked" ); } constructor( address _dispatcher, address _protocolFeeReserve, address _fundDeployer, address _valueInterpreter, address _externalPositionManager, address _feeManager, address _integrationManager, address _policyManager, address _gasRelayPaymasterFactory, address _mlnToken, address _wethToken ) public GasRelayRecipientMixin(_gasRelayPaymasterFactory) { DISPATCHER = _dispatcher; EXTERNAL_POSITION_MANAGER = _externalPositionManager; FEE_MANAGER = _feeManager; FUND_DEPLOYER = _fundDeployer; INTEGRATION_MANAGER = _integrationManager; MLN_TOKEN = _mlnToken; POLICY_MANAGER = _policyManager; PROTOCOL_FEE_RESERVE = _protocolFeeReserve; VALUE_INTERPRETER = _valueInterpreter; WETH_TOKEN = _wethToken; isLib = true; } ///////////// // GENERAL // ///////////// /// @notice Calls a specified action on an Extension /// @param _extension The Extension contract to call (e.g., FeeManager) /// @param _actionId An ID representing the action to take on the extension (see extension) /// @param _callArgs The encoded data for the call /// @dev Used to route arbitrary calls, so that msg.sender is the ComptrollerProxy /// (for access control). Uses a mutex of sorts that allows "permissioned vault actions" /// during calls originating from this function. function callOnExtension( address _extension, uint256 _actionId, bytes calldata _callArgs ) external override locksReentrance allowsPermissionedVaultAction { require( _extension == getFeeManager() || _extension == getIntegrationManager() || _extension == getExternalPositionManager(), "callOnExtension: _extension invalid" ); IExtension(_extension).receiveCallFromComptroller(__msgSender(), _actionId, _callArgs); } /// @notice Makes an arbitrary call with the VaultProxy contract as the sender /// @param _contract The contract to call /// @param _selector The selector to call /// @param _encodedArgs The encoded arguments for the call /// @return returnData_ The data returned by the call function vaultCallOnContract( address _contract, bytes4 _selector, bytes calldata _encodedArgs ) external onlyOwner returns (bytes memory returnData_) { require( IFundDeployer(getFundDeployer()).isAllowedVaultCall( _contract, _selector, keccak256(_encodedArgs) ), "vaultCallOnContract: Not allowed" ); return IVault(getVaultProxy()).callOnContract( _contract, abi.encodePacked(_selector, _encodedArgs) ); } /// @dev Helper to check if a VaultProxy has a pending migration or reconfiguration request function __hasPendingMigrationOrReconfiguration(address _vaultProxy) private view returns (bool hasPendingMigrationOrReconfiguration) { return IDispatcher(getDispatcher()).hasMigrationRequest(_vaultProxy) || IFundDeployer(getFundDeployer()).hasReconfigurationRequest(_vaultProxy); } ////////////////// // PROTOCOL FEE // ////////////////// /// @notice Buys back shares collected as protocol fee at a discounted shares price, using MLN /// @param _sharesAmount The amount of shares to buy back function buyBackProtocolFeeShares(uint256 _sharesAmount) external { address vaultProxyCopy = vaultProxy; require( IVault(vaultProxyCopy).canManageAssets(__msgSender()), "buyBackProtocolFeeShares: Unauthorized" ); uint256 gav = calcGav(); IVault(vaultProxyCopy).buyBackProtocolFeeShares( _sharesAmount, __getBuybackValueInMln(vaultProxyCopy, _sharesAmount, gav), gav ); } /// @notice Sets whether to attempt to buyback protocol fee shares immediately when collected /// @param _nextAutoProtocolFeeSharesBuyback True if protocol fee shares should be attempted /// to be bought back immediately when collected function setAutoProtocolFeeSharesBuyback(bool _nextAutoProtocolFeeSharesBuyback) external onlyOwner { autoProtocolFeeSharesBuyback = _nextAutoProtocolFeeSharesBuyback; emit AutoProtocolFeeSharesBuybackSet(_nextAutoProtocolFeeSharesBuyback); } /// @dev Helper to buyback the max available protocol fee shares, during an auto-buyback function __buyBackMaxProtocolFeeShares(address _vaultProxy, uint256 _gav) private { uint256 sharesAmount = ERC20(_vaultProxy).balanceOf(getProtocolFeeReserve()); uint256 buybackValueInMln = __getBuybackValueInMln(_vaultProxy, sharesAmount, _gav); try IVault(_vaultProxy).buyBackProtocolFeeShares(sharesAmount, buybackValueInMln, _gav) {} catch (bytes memory reason) { emit BuyBackMaxProtocolFeeSharesFailed(reason, sharesAmount, buybackValueInMln, _gav); } } /// @dev Helper to buyback the max available protocol fee shares function __getBuybackValueInMln( address _vaultProxy, uint256 _sharesAmount, uint256 _gav ) private returns (uint256 buybackValueInMln_) { address denominationAssetCopy = getDenominationAsset(); uint256 grossShareValue = __calcGrossShareValue( _gav, ERC20(_vaultProxy).totalSupply(), 10**uint256(ERC20(denominationAssetCopy).decimals()) ); uint256 buybackValueInDenominationAsset = grossShareValue.mul(_sharesAmount).div( SHARES_UNIT ); return IValueInterpreter(getValueInterpreter()).calcCanonicalAssetValue( denominationAssetCopy, buybackValueInDenominationAsset, getMlnToken() ); } //////////////////////////////// // PERMISSIONED VAULT ACTIONS // //////////////////////////////// /// @notice Makes a permissioned, state-changing call on the VaultProxy contract /// @param _action The enum representing the VaultAction to perform on the VaultProxy /// @param _actionData The call data for the action to perform function permissionedVaultAction(IVault.VaultAction _action, bytes calldata _actionData) external override { __assertPermissionedVaultAction(msg.sender, _action); // Validate action as needed if (_action == IVault.VaultAction.RemoveTrackedAsset) { require( abi.decode(_actionData, (address)) != getDenominationAsset(), "permissionedVaultAction: Cannot untrack denomination asset" ); } IVault(getVaultProxy()).receiveValidatedVaultAction(_action, _actionData); } /// @dev Helper to assert that a caller is allowed to perform a particular VaultAction. /// Uses this pattern rather than multiple `require` statements to save on contract size. function __assertPermissionedVaultAction(address _caller, IVault.VaultAction _action) private view { bool validAction; if (permissionedVaultActionAllowed) { // Calls are roughly ordered by likely frequency if (_caller == getIntegrationManager()) { if ( _action == IVault.VaultAction.AddTrackedAsset || _action == IVault.VaultAction.RemoveTrackedAsset || _action == IVault.VaultAction.WithdrawAssetTo || _action == IVault.VaultAction.ApproveAssetSpender ) { validAction = true; } } else if (_caller == getFeeManager()) { if ( _action == IVault.VaultAction.MintShares || _action == IVault.VaultAction.BurnShares || _action == IVault.VaultAction.TransferShares ) { validAction = true; } } else if (_caller == getExternalPositionManager()) { if ( _action == IVault.VaultAction.CallOnExternalPosition || _action == IVault.VaultAction.AddExternalPosition || _action == IVault.VaultAction.RemoveExternalPosition ) { validAction = true; } } } require(validAction, "__assertPermissionedVaultAction: Action not allowed"); } /////////////// // LIFECYCLE // /////////////// // Ordered by execution in the lifecycle /// @notice Initializes a fund with its core config /// @param _denominationAsset The asset in which the fund's value should be denominated /// @param _sharesActionTimelock The minimum number of seconds between any two "shares actions" /// (buying or selling shares) by the same user /// @dev Pseudo-constructor per proxy. /// No need to assert access because this is called atomically on deployment, /// and once it's called, it cannot be called again. function init(address _denominationAsset, uint256 _sharesActionTimelock) external override { require(getDenominationAsset() == address(0), "init: Already initialized"); require( IValueInterpreter(getValueInterpreter()).isSupportedPrimitiveAsset(_denominationAsset), "init: Bad denomination asset" ); denominationAsset = _denominationAsset; sharesActionTimelock = _sharesActionTimelock; } /// @notice Sets the VaultProxy /// @param _vaultProxy The VaultProxy contract /// @dev No need to assert anything beyond FundDeployer access. /// Called atomically with init(), but after ComptrollerProxy has been deployed. function setVaultProxy(address _vaultProxy) external override onlyFundDeployer { vaultProxy = _vaultProxy; emit VaultProxySet(_vaultProxy); } /// @notice Runs atomic logic after a ComptrollerProxy has become its vaultProxy's `accessor` /// @param _isMigration True if a migrated fund is being activated /// @dev No need to assert anything beyond FundDeployer access. function activate(bool _isMigration) external override onlyFundDeployer { address vaultProxyCopy = getVaultProxy(); if (_isMigration) { // Distribute any shares in the VaultProxy to the fund owner. // This is a mechanism to ensure that even in the edge case of a fund being unable // to payout fee shares owed during migration, these shares are not lost. uint256 sharesDue = ERC20(vaultProxyCopy).balanceOf(vaultProxyCopy); if (sharesDue > 0) { IVault(vaultProxyCopy).transferShares( vaultProxyCopy, IVault(vaultProxyCopy).getOwner(), sharesDue ); emit MigratedSharesDuePaid(sharesDue); } } IVault(vaultProxyCopy).addTrackedAsset(getDenominationAsset()); // Activate extensions IExtension(getFeeManager()).activateForFund(_isMigration); IExtension(getPolicyManager()).activateForFund(_isMigration); } /// @notice Wind down and destroy a ComptrollerProxy that is active /// @param _deactivateFeeManagerGasLimit The amount of gas to forward to deactivate the FeeManager /// @param _payProtocolFeeGasLimit The amount of gas to forward to pay the protocol fee /// @dev No need to assert anything beyond FundDeployer access. /// Uses the try/catch pattern throughout out of an abundance of caution for the function's success. /// All external calls must use limited forwarded gas to ensure that a migration to another release /// does not get bricked by logic that consumes too much gas for the block limit. function destructActivated( uint256 _deactivateFeeManagerGasLimit, uint256 _payProtocolFeeGasLimit ) external override onlyFundDeployer allowsPermissionedVaultAction { // Forwarding limited gas here also protects fee recipients by guaranteeing that fee payout logic // will run in the next function call try IVault(getVaultProxy()).payProtocolFee{gas: _payProtocolFeeGasLimit}() {} catch { emit PayProtocolFeeDuringDestructFailed(); } // Do not attempt to auto-buyback protocol fee shares in this case, // as the call is gav-dependent and can consume too much gas // Deactivate extensions only as-necessary // Pays out shares outstanding for fees try IExtension(getFeeManager()).deactivateForFund{gas: _deactivateFeeManagerGasLimit}() {} catch { emit DeactivateFeeManagerFailed(); } __selfDestruct(); } /// @notice Destroy a ComptrollerProxy that has not been activated function destructUnactivated() external override onlyFundDeployer { __selfDestruct(); } /// @dev Helper to self-destruct the contract. /// There should never be ETH in the ComptrollerLib, /// so no need to waste gas to get the fund owner function __selfDestruct() private { // Not necessary, but failsafe to protect the lib against selfdestruct require(!isLib, "__selfDestruct: Only delegate callable"); selfdestruct(payable(address(this))); } //////////////// // ACCOUNTING // //////////////// /// @notice Calculates the gross asset value (GAV) of the fund /// @return gav_ The fund GAV function calcGav() public override returns (uint256 gav_) { address vaultProxyAddress = getVaultProxy(); address[] memory assets = IVault(vaultProxyAddress).getTrackedAssets(); address[] memory externalPositions = IVault(vaultProxyAddress) .getActiveExternalPositions(); if (assets.length == 0 && externalPositions.length == 0) { return 0; } uint256[] memory balances = new uint256[](assets.length); for (uint256 i; i < assets.length; i++) { balances[i] = ERC20(assets[i]).balanceOf(vaultProxyAddress); } gav_ = IValueInterpreter(getValueInterpreter()).calcCanonicalAssetsTotalValue( assets, balances, getDenominationAsset() ); if (externalPositions.length > 0) { for (uint256 i; i < externalPositions.length; i++) { uint256 externalPositionValue = __calcExternalPositionValue(externalPositions[i]); gav_ = gav_.add(externalPositionValue); } } return gav_; } /// @notice Calculates the gross value of 1 unit of shares in the fund's denomination asset /// @return grossShareValue_ The amount of the denomination asset per share /// @dev Does not account for any fees outstanding. function calcGrossShareValue() external override returns (uint256 grossShareValue_) { uint256 gav = calcGav(); grossShareValue_ = __calcGrossShareValue( gav, ERC20(getVaultProxy()).totalSupply(), 10**uint256(ERC20(getDenominationAsset()).decimals()) ); return grossShareValue_; } // @dev Helper for calculating a external position value. Prevents from stack too deep function __calcExternalPositionValue(address _externalPosition) private returns (uint256 value_) { (address[] memory managedAssets, uint256[] memory managedAmounts) = IExternalPosition( _externalPosition ) .getManagedAssets(); uint256 managedValue = IValueInterpreter(getValueInterpreter()) .calcCanonicalAssetsTotalValue(managedAssets, managedAmounts, getDenominationAsset()); (address[] memory debtAssets, uint256[] memory debtAmounts) = IExternalPosition( _externalPosition ) .getDebtAssets(); uint256 debtValue = IValueInterpreter(getValueInterpreter()).calcCanonicalAssetsTotalValue( debtAssets, debtAmounts, getDenominationAsset() ); if (managedValue > debtValue) { value_ = managedValue.sub(debtValue); } return value_; } /// @dev Helper for calculating the gross share value function __calcGrossShareValue( uint256 _gav, uint256 _sharesSupply, uint256 _denominationAssetUnit ) private pure returns (uint256 grossShareValue_) { if (_sharesSupply == 0) { return _denominationAssetUnit; } return _gav.mul(SHARES_UNIT).div(_sharesSupply); } /////////////////// // PARTICIPATION // /////////////////// // BUY SHARES /// @notice Buys shares on behalf of another user /// @param _buyer The account on behalf of whom to buy shares /// @param _investmentAmount The amount of the fund's denomination asset with which to buy shares /// @param _minSharesQuantity The minimum quantity of shares to buy /// @return sharesReceived_ The actual amount of shares received /// @dev This function is freely callable if there is no sharesActionTimelock set, but it is /// limited to a list of trusted callers otherwise, in order to prevent a griefing attack /// where the caller buys shares for a _buyer, thereby resetting their lastSharesBought value. function buySharesOnBehalf( address _buyer, uint256 _investmentAmount, uint256 _minSharesQuantity ) external returns (uint256 sharesReceived_) { bool hasSharesActionTimelock = getSharesActionTimelock() > 0; address canonicalSender = __msgSender(); require( !hasSharesActionTimelock || IFundDeployer(getFundDeployer()).isAllowedBuySharesOnBehalfCaller(canonicalSender), "buySharesOnBehalf: Unauthorized" ); return __buyShares( _buyer, _investmentAmount, _minSharesQuantity, hasSharesActionTimelock, canonicalSender ); } /// @notice Buys shares /// @param _investmentAmount The amount of the fund's denomination asset /// with which to buy shares /// @param _minSharesQuantity The minimum quantity of shares to buy /// @return sharesReceived_ The actual amount of shares received function buyShares(uint256 _investmentAmount, uint256 _minSharesQuantity) external returns (uint256 sharesReceived_) { bool hasSharesActionTimelock = getSharesActionTimelock() > 0; address canonicalSender = __msgSender(); return __buyShares( canonicalSender, _investmentAmount, _minSharesQuantity, hasSharesActionTimelock, canonicalSender ); } /// @dev Helper for buy shares logic function __buyShares( address _buyer, uint256 _investmentAmount, uint256 _minSharesQuantity, bool _hasSharesActionTimelock, address _canonicalSender ) private locksReentrance allowsPermissionedVaultAction returns (uint256 sharesReceived_) { // Enforcing a _minSharesQuantity also validates `_investmentAmount > 0` // and guarantees the function cannot succeed while minting 0 shares require(_minSharesQuantity > 0, "__buyShares: _minSharesQuantity must be >0"); address vaultProxyCopy = getVaultProxy(); require( !_hasSharesActionTimelock || !__hasPendingMigrationOrReconfiguration(vaultProxyCopy), "__buyShares: Pending migration or reconfiguration" ); uint256 gav = calcGav(); // Gives Extensions a chance to run logic prior to the minting of bought shares. // Fees implementing this hook should be aware that // it might be the case that _investmentAmount != actualInvestmentAmount, // if the denomination asset charges a transfer fee, for example. __preBuySharesHook(_buyer, _investmentAmount, gav); // Pay the protocol fee after running other fees, but before minting new shares IVault(vaultProxyCopy).payProtocolFee(); if (doesAutoProtocolFeeSharesBuyback()) { __buyBackMaxProtocolFeeShares(vaultProxyCopy, gav); } // Transfer the investment asset to the fund. // Does not follow the checks-effects-interactions pattern, but it is necessary to // do this delta balance calculation before calculating shares to mint. uint256 receivedInvestmentAmount = __transferFromWithReceivedAmount( getDenominationAsset(), _canonicalSender, vaultProxyCopy, _investmentAmount ); // Calculate the amount of shares to issue with the investment amount uint256 sharePrice = __calcGrossShareValue( gav, ERC20(vaultProxyCopy).totalSupply(), 10**uint256(ERC20(getDenominationAsset()).decimals()) ); uint256 sharesIssued = receivedInvestmentAmount.mul(SHARES_UNIT).div(sharePrice); // Mint shares to the buyer uint256 prevBuyerShares = ERC20(vaultProxyCopy).balanceOf(_buyer); IVault(vaultProxyCopy).mintShares(_buyer, sharesIssued); // Gives Extensions a chance to run logic after shares are issued __postBuySharesHook(_buyer, receivedInvestmentAmount, sharesIssued, gav); // The number of actual shares received may differ from shares issued due to // how the PostBuyShares hooks are invoked by Extensions (i.e., fees) sharesReceived_ = ERC20(vaultProxyCopy).balanceOf(_buyer).sub(prevBuyerShares); require( sharesReceived_ >= _minSharesQuantity, "__buyShares: Shares received < _minSharesQuantity" ); if (_hasSharesActionTimelock) { acctToLastSharesBoughtTimestamp[_buyer] = block.timestamp; } emit SharesBought(_buyer, receivedInvestmentAmount, sharesIssued, sharesReceived_); return sharesReceived_; } /// @dev Helper for Extension actions immediately prior to issuing shares function __preBuySharesHook( address _buyer, uint256 _investmentAmount, uint256 _gav ) private { IFeeManager(getFeeManager()).invokeHook( IFeeManager.FeeHook.PreBuyShares, abi.encode(_buyer, _investmentAmount), _gav ); } /// @dev Helper for Extension actions immediately after issuing shares. /// This could be cleaned up so both Extensions take the same encoded args and handle GAV /// in the same way, but there is not the obvious need for gas savings of recycling /// the GAV value for the current policies as there is for the fees. function __postBuySharesHook( address _buyer, uint256 _investmentAmount, uint256 _sharesIssued, uint256 _preBuySharesGav ) private { uint256 gav = _preBuySharesGav.add(_investmentAmount); IFeeManager(getFeeManager()).invokeHook( IFeeManager.FeeHook.PostBuyShares, abi.encode(_buyer, _investmentAmount, _sharesIssued), gav ); IPolicyManager(getPolicyManager()).validatePolicies( address(this), IPolicyManager.PolicyHook.PostBuyShares, abi.encode(_buyer, _investmentAmount, _sharesIssued, gav) ); } /// @dev Helper to execute ERC20.transferFrom() while calculating the actual amount received function __transferFromWithReceivedAmount( address _asset, address _sender, address _recipient, uint256 _transferAmount ) private returns (uint256 receivedAmount_) { uint256 preTransferRecipientBalance = ERC20(_asset).balanceOf(_recipient); ERC20(_asset).safeTransferFrom(_sender, _recipient, _transferAmount); return ERC20(_asset).balanceOf(_recipient).sub(preTransferRecipientBalance); } // REDEEM SHARES /// @notice Redeems a specified amount of the sender's shares for specified asset proportions /// @param _recipient The account that will receive the specified assets /// @param _sharesQuantity The quantity of shares to redeem /// @param _payoutAssets The assets to payout /// @param _payoutAssetPercentages The percentage of the owed amount to pay out in each asset /// @return payoutAmounts_ The amount of each asset paid out to the _recipient /// @dev Redeem all shares of the sender by setting _sharesQuantity to the max uint value. /// _payoutAssetPercentages must total exactly 100%. In order to specify less and forgo the /// remaining gav owed on the redeemed shares, pass in address(0) with the percentage to forego. /// Unlike redeemSharesInKind(), this function allows policies to run and prevent redemption. function redeemSharesForSpecificAssets( address _recipient, uint256 _sharesQuantity, address[] calldata _payoutAssets, uint256[] calldata _payoutAssetPercentages ) external locksReentrance returns (uint256[] memory payoutAmounts_) { address canonicalSender = __msgSender(); require( _payoutAssets.length == _payoutAssetPercentages.length, "redeemSharesForSpecificAssets: Unequal arrays" ); require( _payoutAssets.isUniqueSet(), "redeemSharesForSpecificAssets: Duplicate payout asset" ); uint256 gav = calcGav(); IVault vaultProxyContract = IVault(getVaultProxy()); (uint256 sharesToRedeem, uint256 sharesSupply) = __redeemSharesSetup( vaultProxyContract, canonicalSender, _sharesQuantity, true, gav ); payoutAmounts_ = __payoutSpecifiedAssetPercentages( vaultProxyContract, _recipient, _payoutAssets, _payoutAssetPercentages, gav.mul(sharesToRedeem).div(sharesSupply) ); // Run post-redemption in order to have access to the payoutAmounts __postRedeemSharesForSpecificAssetsHook( canonicalSender, _recipient, sharesToRedeem, _payoutAssets, payoutAmounts_, gav ); emit SharesRedeemed( canonicalSender, _recipient, sharesToRedeem, _payoutAssets, payoutAmounts_ ); return payoutAmounts_; } /// @notice Redeems a specified amount of the sender's shares /// for a proportionate slice of the vault's assets /// @param _recipient The account that will receive the proportionate slice of assets /// @param _sharesQuantity The quantity of shares to redeem /// @param _additionalAssets Additional (non-tracked) assets to claim /// @param _assetsToSkip Tracked assets to forfeit /// @return payoutAssets_ The assets paid out to the _recipient /// @return payoutAmounts_ The amount of each asset paid out to the _recipient /// @dev Redeem all shares of the sender by setting _sharesQuantity to the max uint value. /// Any claim to passed _assetsToSkip will be forfeited entirely. This should generally /// only be exercised if a bad asset is causing redemption to fail. /// This function should never fail without a way to bypass the failure, which is assured /// through two mechanisms: /// 1. The FeeManager is called with the try/catch pattern to assure that calls to it /// can never block redemption. /// 2. If a token fails upon transfer(), that token can be skipped (and its balance forfeited) /// by explicitly specifying _assetsToSkip. /// Because of these assurances, shares should always be redeemable, with the exception /// of the timelock period on shares actions that must be respected. function redeemSharesInKind( address _recipient, uint256 _sharesQuantity, address[] calldata _additionalAssets, address[] calldata _assetsToSkip ) external locksReentrance returns (address[] memory payoutAssets_, uint256[] memory payoutAmounts_) { address canonicalSender = __msgSender(); require( _additionalAssets.isUniqueSet(), "redeemSharesInKind: _additionalAssets contains duplicates" ); require( _assetsToSkip.isUniqueSet(), "redeemSharesInKind: _assetsToSkip contains duplicates" ); // Parse the payout assets given optional params to add or skip assets. // Note that there is no validation that the _additionalAssets are known assets to // the protocol. This means that the redeemer could specify a malicious asset, // but since all state-changing, user-callable functions on this contract share the // non-reentrant modifier, there is nowhere to perform a reentrancy attack. payoutAssets_ = __parseRedemptionPayoutAssets( IVault(vaultProxy).getTrackedAssets(), _additionalAssets, _assetsToSkip ); // If protocol fee shares will be auto-bought back, attempt to calculate GAV to pass into fees, // as we will require GAV later during the buyback. uint256 gavOrZero; if (doesAutoProtocolFeeSharesBuyback()) { // Since GAV calculation can fail with a revering price or a no-longer-supported asset, // we must try/catch GAV calculation to ensure that in-kind redemption can still succeed try this.calcGav() returns (uint256 gav) { gavOrZero = gav; } catch { emit RedeemSharesInKindCalcGavFailed(); } } (uint256 sharesToRedeem, uint256 sharesSupply) = __redeemSharesSetup( IVault(vaultProxy), canonicalSender, _sharesQuantity, false, gavOrZero ); // Calculate and transfer payout asset amounts due to _recipient payoutAmounts_ = new uint256[](payoutAssets_.length); for (uint256 i; i < payoutAssets_.length; i++) { payoutAmounts_[i] = ERC20(payoutAssets_[i]) .balanceOf(vaultProxy) .mul(sharesToRedeem) .div(sharesSupply); // Transfer payout asset to _recipient if (payoutAmounts_[i] > 0) { IVault(vaultProxy).withdrawAssetTo( payoutAssets_[i], _recipient, payoutAmounts_[i] ); } } emit SharesRedeemed( canonicalSender, _recipient, sharesToRedeem, payoutAssets_, payoutAmounts_ ); return (payoutAssets_, payoutAmounts_); } /// @dev Helper to parse an array of payout assets during redemption, taking into account /// additional assets and assets to skip. _assetsToSkip ignores _additionalAssets. /// All input arrays are assumed to be unique. function __parseRedemptionPayoutAssets( address[] memory _trackedAssets, address[] memory _additionalAssets, address[] memory _assetsToSkip ) private pure returns (address[] memory payoutAssets_) { address[] memory trackedAssetsToPayout = _trackedAssets.removeItems(_assetsToSkip); if (_additionalAssets.length == 0) { return trackedAssetsToPayout; } // Add additional assets. Duplicates of trackedAssets are ignored. bool[] memory indexesToAdd = new bool[](_additionalAssets.length); uint256 additionalItemsCount; for (uint256 i; i < _additionalAssets.length; i++) { if (!trackedAssetsToPayout.contains(_additionalAssets[i])) { indexesToAdd[i] = true; additionalItemsCount++; } } if (additionalItemsCount == 0) { return trackedAssetsToPayout; } payoutAssets_ = new address[](trackedAssetsToPayout.length.add(additionalItemsCount)); for (uint256 i; i < trackedAssetsToPayout.length; i++) { payoutAssets_[i] = trackedAssetsToPayout[i]; } uint256 payoutAssetsIndex = trackedAssetsToPayout.length; for (uint256 i; i < _additionalAssets.length; i++) { if (indexesToAdd[i]) { payoutAssets_[payoutAssetsIndex] = _additionalAssets[i]; payoutAssetsIndex++; } } return payoutAssets_; } /// @dev Helper to payout specified asset percentages during redeemSharesForSpecificAssets() function __payoutSpecifiedAssetPercentages( IVault vaultProxyContract, address _recipient, address[] calldata _payoutAssets, uint256[] calldata _payoutAssetPercentages, uint256 _owedGav ) private returns (uint256[] memory payoutAmounts_) { address denominationAssetCopy = getDenominationAsset(); uint256 percentagesTotal; payoutAmounts_ = new uint256[](_payoutAssets.length); for (uint256 i; i < _payoutAssets.length; i++) { percentagesTotal = percentagesTotal.add(_payoutAssetPercentages[i]); // Used to explicitly specify less than 100% in total _payoutAssetPercentages if (_payoutAssets[i] == SPECIFIC_ASSET_REDEMPTION_DUMMY_FORFEIT_ADDRESS) { continue; } payoutAmounts_[i] = IValueInterpreter(getValueInterpreter()).calcCanonicalAssetValue( denominationAssetCopy, _owedGav.mul(_payoutAssetPercentages[i]).div(ONE_HUNDRED_PERCENT), _payoutAssets[i] ); // Guards against corner case of primitive-to-derivative asset conversion that floors to 0, // or redeeming a very low shares amount and/or percentage where asset value owed is 0 require( payoutAmounts_[i] > 0, "__payoutSpecifiedAssetPercentages: Zero amount for asset" ); vaultProxyContract.withdrawAssetTo(_payoutAssets[i], _recipient, payoutAmounts_[i]); } require( percentagesTotal == ONE_HUNDRED_PERCENT, "__payoutSpecifiedAssetPercentages: Percents must total 100%" ); return payoutAmounts_; } /// @dev Helper for system actions immediately prior to redeeming shares. /// Policy validation is not currently allowed on redemption, to ensure continuous redeemability. function __preRedeemSharesHook( address _redeemer, uint256 _sharesToRedeem, bool _forSpecifiedAssets, uint256 _gavIfCalculated ) private allowsPermissionedVaultAction { try IFeeManager(getFeeManager()).invokeHook( IFeeManager.FeeHook.PreRedeemShares, abi.encode(_redeemer, _sharesToRedeem, _forSpecifiedAssets), _gavIfCalculated ) {} catch (bytes memory reason) { emit PreRedeemSharesHookFailed(reason, _redeemer, _sharesToRedeem); } } /// @dev Helper to run policy validation after other logic for redeeming shares for specific assets. /// Avoids stack-too-deep error. function __postRedeemSharesForSpecificAssetsHook( address _redeemer, address _recipient, uint256 _sharesToRedeemPostFees, address[] memory _assets, uint256[] memory _assetAmounts, uint256 _gavPreRedeem ) private { IPolicyManager(getPolicyManager()).validatePolicies( address(this), IPolicyManager.PolicyHook.RedeemSharesForSpecificAssets, abi.encode( _redeemer, _recipient, _sharesToRedeemPostFees, _assets, _assetAmounts, _gavPreRedeem ) ); } /// @dev Helper to execute common pre-shares redemption logic function __redeemSharesSetup( IVault vaultProxyContract, address _redeemer, uint256 _sharesQuantityInput, bool _forSpecifiedAssets, uint256 _gavIfCalculated ) private returns (uint256 sharesToRedeem_, uint256 sharesSupply_) { __assertSharesActionNotTimelocked(address(vaultProxyContract), _redeemer); ERC20 sharesContract = ERC20(address(vaultProxyContract)); uint256 preFeesRedeemerSharesBalance = sharesContract.balanceOf(_redeemer); if (_sharesQuantityInput == type(uint256).max) { sharesToRedeem_ = preFeesRedeemerSharesBalance; } else { sharesToRedeem_ = _sharesQuantityInput; } require(sharesToRedeem_ > 0, "__redeemSharesSetup: No shares to redeem"); __preRedeemSharesHook(_redeemer, sharesToRedeem_, _forSpecifiedAssets, _gavIfCalculated); // Update the redemption amount if fees were charged (or accrued) to the redeemer uint256 postFeesRedeemerSharesBalance = sharesContract.balanceOf(_redeemer); if (_sharesQuantityInput == type(uint256).max) { sharesToRedeem_ = postFeesRedeemerSharesBalance; } else if (postFeesRedeemerSharesBalance < preFeesRedeemerSharesBalance) { sharesToRedeem_ = sharesToRedeem_.sub( preFeesRedeemerSharesBalance.sub(postFeesRedeemerSharesBalance) ); } // Pay the protocol fee after running other fees, but before burning shares vaultProxyContract.payProtocolFee(); if (_gavIfCalculated > 0 && doesAutoProtocolFeeSharesBuyback()) { __buyBackMaxProtocolFeeShares(address(vaultProxyContract), _gavIfCalculated); } // Destroy the shares after getting the shares supply sharesSupply_ = sharesContract.totalSupply(); vaultProxyContract.burnShares(_redeemer, sharesToRedeem_); return (sharesToRedeem_, sharesSupply_); } // TRANSFER SHARES /// @notice Runs logic prior to transferring shares that are not freely transferable /// @param _sender The sender of the shares /// @param _recipient The recipient of the shares /// @param _amount The amount of shares function preTransferSharesHook( address _sender, address _recipient, uint256 _amount ) external override { address vaultProxyCopy = getVaultProxy(); require(msg.sender == vaultProxyCopy, "preTransferSharesHook: Only VaultProxy callable"); __assertSharesActionNotTimelocked(vaultProxyCopy, _sender); IPolicyManager(getPolicyManager()).validatePolicies( address(this), IPolicyManager.PolicyHook.PreTransferShares, abi.encode(_sender, _recipient, _amount) ); } /// @notice Runs logic prior to transferring shares that are freely transferable /// @param _sender The sender of the shares /// @dev No need to validate caller, as policies are not run function preTransferSharesHookFreelyTransferable(address _sender) external view override { __assertSharesActionNotTimelocked(getVaultProxy(), _sender); } ///////////////// // GAS RELAYER // ///////////////// /// @notice Deploys a paymaster contract and deposits WETH, enabling gas relaying function deployGasRelayPaymaster() external onlyOwnerNotRelayable { require( getGasRelayPaymaster() == address(0), "deployGasRelayPaymaster: Paymaster already deployed" ); bytes memory constructData = abi.encodeWithSignature("init(address)", getVaultProxy()); address paymaster = IBeaconProxyFactory(getGasRelayPaymasterFactory()).deployProxy( constructData ); __setGasRelayPaymaster(paymaster); __depositToGasRelayPaymaster(paymaster); } /// @notice Tops up the gas relay paymaster deposit function depositToGasRelayPaymaster() external onlyOwner { __depositToGasRelayPaymaster(getGasRelayPaymaster()); } /// @notice Pull WETH from vault to gas relay paymaster /// @param _amount Amount of the WETH to pull from the vault function pullWethForGasRelayer(uint256 _amount) external override onlyGasRelayPaymaster { IVault(getVaultProxy()).withdrawAssetTo(getWethToken(), getGasRelayPaymaster(), _amount); } /// @notice Sets the gasRelayPaymaster variable value /// @param _nextGasRelayPaymaster The next gasRelayPaymaster value function setGasRelayPaymaster(address _nextGasRelayPaymaster) external override onlyFundDeployer { __setGasRelayPaymaster(_nextGasRelayPaymaster); } /// @notice Removes the gas relay paymaster, withdrawing the remaining WETH balance /// and disabling gas relaying function shutdownGasRelayPaymaster() external onlyOwnerNotRelayable { IGasRelayPaymaster(gasRelayPaymaster).withdrawBalance(); IVault(vaultProxy).addTrackedAsset(getWethToken()); delete gasRelayPaymaster; emit GasRelayPaymasterSet(address(0)); } /// @dev Helper to deposit to the gas relay paymaster function __depositToGasRelayPaymaster(address _paymaster) private { IGasRelayPaymaster(_paymaster).deposit(); } /// @dev Helper to set the next `gasRelayPaymaster` variable function __setGasRelayPaymaster(address _nextGasRelayPaymaster) private { gasRelayPaymaster = _nextGasRelayPaymaster; emit GasRelayPaymasterSet(_nextGasRelayPaymaster); } /////////////////// // STATE GETTERS // /////////////////// // LIB IMMUTABLES /// @notice Gets the `DISPATCHER` variable /// @return dispatcher_ The `DISPATCHER` variable value function getDispatcher() public view returns (address dispatcher_) { return DISPATCHER; } /// @notice Gets the `EXTERNAL_POSITION_MANAGER` variable /// @return externalPositionManager_ The `EXTERNAL_POSITION_MANAGER` variable value function getExternalPositionManager() public view override returns (address externalPositionManager_) { return EXTERNAL_POSITION_MANAGER; } /// @notice Gets the `FEE_MANAGER` variable /// @return feeManager_ The `FEE_MANAGER` variable value function getFeeManager() public view override returns (address feeManager_) { return FEE_MANAGER; } /// @notice Gets the `FUND_DEPLOYER` variable /// @return fundDeployer_ The `FUND_DEPLOYER` variable value function getFundDeployer() public view override returns (address fundDeployer_) { return FUND_DEPLOYER; } /// @notice Gets the `INTEGRATION_MANAGER` variable /// @return integrationManager_ The `INTEGRATION_MANAGER` variable value function getIntegrationManager() public view override returns (address integrationManager_) { return INTEGRATION_MANAGER; } /// @notice Gets the `MLN_TOKEN` variable /// @return mlnToken_ The `MLN_TOKEN` variable value function getMlnToken() public view returns (address mlnToken_) { return MLN_TOKEN; } /// @notice Gets the `POLICY_MANAGER` variable /// @return policyManager_ The `POLICY_MANAGER` variable value function getPolicyManager() public view override returns (address policyManager_) { return POLICY_MANAGER; } /// @notice Gets the `PROTOCOL_FEE_RESERVE` variable /// @return protocolFeeReserve_ The `PROTOCOL_FEE_RESERVE` variable value function getProtocolFeeReserve() public view returns (address protocolFeeReserve_) { return PROTOCOL_FEE_RESERVE; } /// @notice Gets the `VALUE_INTERPRETER` variable /// @return valueInterpreter_ The `VALUE_INTERPRETER` variable value function getValueInterpreter() public view returns (address valueInterpreter_) { return VALUE_INTERPRETER; } /// @notice Gets the `WETH_TOKEN` variable /// @return wethToken_ The `WETH_TOKEN` variable value function getWethToken() public view returns (address wethToken_) { return WETH_TOKEN; } // PROXY STORAGE /// @notice Checks if collected protocol fee shares are automatically bought back /// while buying or redeeming shares /// @return doesAutoBuyback_ True if shares are automatically bought back function doesAutoProtocolFeeSharesBuyback() public view returns (bool doesAutoBuyback_) { return autoProtocolFeeSharesBuyback; } /// @notice Gets the `denominationAsset` variable /// @return denominationAsset_ The `denominationAsset` variable value function getDenominationAsset() public view override returns (address denominationAsset_) { return denominationAsset; } /// @notice Gets the `gasRelayPaymaster` variable /// @return gasRelayPaymaster_ The `gasRelayPaymaster` variable value function getGasRelayPaymaster() public view override returns (address gasRelayPaymaster_) { return gasRelayPaymaster; } /// @notice Gets the timestamp of the last time shares were bought for a given account /// @param _who The account for which to get the timestamp /// @return lastSharesBoughtTimestamp_ The timestamp of the last shares bought function getLastSharesBoughtTimestampForAccount(address _who) public view returns (uint256 lastSharesBoughtTimestamp_) { return acctToLastSharesBoughtTimestamp[_who]; } /// @notice Gets the `sharesActionTimelock` variable /// @return sharesActionTimelock_ The `sharesActionTimelock` variable value function getSharesActionTimelock() public view returns (uint256 sharesActionTimelock_) { return sharesActionTimelock; } /// @notice Gets the `vaultProxy` variable /// @return vaultProxy_ The `vaultProxy` variable value function getVaultProxy() public view override returns (address vaultProxy_) { return vaultProxy; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "../vault/IVault.sol"; /// @title IComptroller Interface /// @author Enzyme Council <[email protected]> interface IComptroller { function activate(bool) external; function calcGav() external returns (uint256); function calcGrossShareValue() external returns (uint256); function callOnExtension( address, uint256, bytes calldata ) external; function destructActivated(uint256, uint256) external; function destructUnactivated() external; function getDenominationAsset() external view returns (address); function getExternalPositionManager() external view returns (address); function getFeeManager() external view returns (address); function getFundDeployer() external view returns (address); function getGasRelayPaymaster() external view returns (address); function getIntegrationManager() external view returns (address); function getPolicyManager() external view returns (address); function getVaultProxy() external view returns (address); function init(address, uint256) external; function permissionedVaultAction(IVault.VaultAction, bytes calldata) external; function preTransferSharesHook( address, address, uint256 ) external; function preTransferSharesHookFreelyTransferable(address) external view; function setGasRelayPaymaster(address) external; function setVaultProxy(address) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "../../../../persistent/vault/interfaces/IExternalPositionVault.sol"; import "../../../../persistent/vault/interfaces/IFreelyTransferableSharesVault.sol"; import "../../../../persistent/vault/interfaces/IMigratableVault.sol"; /// @title IVault Interface /// @author Enzyme Council <[email protected]> interface IVault is IMigratableVault, IFreelyTransferableSharesVault, IExternalPositionVault { enum VaultAction { None, // Shares management BurnShares, MintShares, TransferShares, // Asset management AddTrackedAsset, ApproveAssetSpender, RemoveTrackedAsset, WithdrawAssetTo, // External position management AddExternalPosition, CallOnExternalPosition, RemoveExternalPosition } function addTrackedAsset(address) external; function burnShares(address, uint256) external; function buyBackProtocolFeeShares( uint256, uint256, uint256 ) external; function callOnContract(address, bytes calldata) external returns (bytes memory); function canManageAssets(address) external view returns (bool); function canRelayCalls(address) external view returns (bool); function getAccessor() external view returns (address); function getOwner() external view returns (address); function getActiveExternalPositions() external view returns (address[] memory); function getTrackedAssets() external view returns (address[] memory); function isActiveExternalPosition(address) external view returns (bool); function isTrackedAsset(address) external view returns (bool); function mintShares(address, uint256) external; function payProtocolFee() external; function receiveValidatedVaultAction(VaultAction, bytes calldata) external; function setAccessorForFundReconfiguration(address) external; function setSymbol(string calldata) external; function transferShares( address, address, uint256 ) external; function withdrawAssetTo( address, address, uint256 ) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20Burnable.sol"; import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; import "../../../../persistent/dispatcher/IDispatcher.sol"; import "../../../../persistent/external-positions/IExternalPosition.sol"; import "../../../../persistent/protocol-fee-reserve/interfaces/IProtocolFeeReserve1.sol"; import "../../../../persistent/vault/VaultLibBase2.sol"; import "../../../infrastructure/gas-relayer/GasRelayRecipientMixin.sol"; import "../../../infrastructure/protocol-fees/IProtocolFeeTracker.sol"; import "../../../extensions/external-position-manager/IExternalPositionManager.sol"; import "../../../interfaces/IWETH.sol"; import "../../../utils/AddressArrayLib.sol"; import "../comptroller/IComptroller.sol"; import "./IVault.sol"; /// @title VaultLib Contract /// @author Enzyme Council <[email protected]> /// @notice The per-release proxiable library contract for VaultProxy /// @dev The difference in terminology between "asset" and "trackedAsset" is intentional. /// A fund might actually have asset balances of un-tracked assets, /// but only tracked assets are used in gav calculations. /// Note that this contract inherits VaultLibSafeMath (a verbatim Open Zeppelin SafeMath copy) /// from SharesTokenBase via VaultLibBase2 contract VaultLib is VaultLibBase2, IVault, GasRelayRecipientMixin { using AddressArrayLib for address[]; using SafeERC20 for ERC20; address private immutable EXTERNAL_POSITION_MANAGER; // The account to which to send $MLN earmarked for burn. // A value of `address(0)` signifies burning from the current contract. address private immutable MLN_BURNER; address private immutable MLN_TOKEN; // "Positions" are "tracked assets" + active "external positions" // Before updating POSITIONS_LIMIT in the future, it is important to consider: // 1. The highest positions limit ever allowed in the protocol // 2. That the next value will need to be respected by all future releases uint256 private immutable POSITIONS_LIMIT; address private immutable PROTOCOL_FEE_RESERVE; address private immutable PROTOCOL_FEE_TRACKER; address private immutable WETH_TOKEN; modifier notShares(address _asset) { require(_asset != address(this), "Cannot act on shares"); _; } modifier onlyAccessor() { require(msg.sender == accessor, "Only the designated accessor can make this call"); _; } modifier onlyOwner() { require(__msgSender() == owner, "Only the owner can call this function"); _; } constructor( address _externalPositionManager, address _gasRelayPaymasterFactory, address _protocolFeeReserve, address _protocolFeeTracker, address _mlnToken, address _mlnBurner, address _wethToken, uint256 _positionsLimit ) public GasRelayRecipientMixin(_gasRelayPaymasterFactory) { EXTERNAL_POSITION_MANAGER = _externalPositionManager; MLN_BURNER = _mlnBurner; MLN_TOKEN = _mlnToken; POSITIONS_LIMIT = _positionsLimit; PROTOCOL_FEE_RESERVE = _protocolFeeReserve; PROTOCOL_FEE_TRACKER = _protocolFeeTracker; WETH_TOKEN = _wethToken; } /// @dev If a VaultProxy receives ETH, immediately wrap into WETH. /// Will not be able to receive ETH via .transfer() or .send() due to limited gas forwarding. receive() external payable { uint256 ethAmount = payable(address(this)).balance; IWETH(payable(getWethToken())).deposit{value: ethAmount}(); emit EthReceived(msg.sender, ethAmount); } ///////////// // GENERAL // ///////////// /// @notice Gets the external position library contract for a given type /// @param _typeId The type for which to get the external position library /// @return externalPositionLib_ The external position library function getExternalPositionLibForType(uint256 _typeId) external view override returns (address externalPositionLib_) { return IExternalPositionManager(getExternalPositionManager()).getExternalPositionLibForType( _typeId ); } /// @notice Sets shares as (permanently) freely transferable /// @dev Once set, this can never be allowed to be unset, as it provides a critical /// transferability guarantee to liquidity pools and other smart contract holders /// that rely on transfers to function properly. Enabling this option will skip all /// policies run upon transferring shares, but will still respect the shares action timelock. function setFreelyTransferableShares() external onlyOwner { require(!sharesAreFreelyTransferable(), "setFreelyTransferableShares: Already set"); freelyTransferableShares = true; emit FreelyTransferableSharesSet(); } /// @notice Sets the shares name /// @param _nextName The next name value /// @dev Owners should consider the implications of changing an ERC20 name post-deployment, /// e.g., some apps/dapps may cache token names for display purposes, so changing the name /// in contract state may not be reflected in third party applications as desired. function setName(string calldata _nextName) external onlyOwner { sharesName = _nextName; emit NameSet(_nextName); } /// @notice Sets the shares token symbol /// @param _nextSymbol The next symbol value /// @dev Owners should consider the implications of changing an ERC20 symbol post-deployment, /// e.g., some apps/dapps may cache token symbols for display purposes, so changing the symbol /// in contract state may not be reflected in third party applications as desired. /// Only callable by the FundDeployer during vault creation or by the vault owner. function setSymbol(string calldata _nextSymbol) external override { require(__msgSender() == owner || msg.sender == getFundDeployer(), "Unauthorized"); sharesSymbol = _nextSymbol; emit SymbolSet(_nextSymbol); } //////////////////////// // PERMISSIONED ROLES // //////////////////////// /// @notice Registers accounts that can manage vault holdings within the protocol /// @param _managers The accounts to add as asset managers function addAssetManagers(address[] calldata _managers) external onlyOwner { for (uint256 i; i < _managers.length; i++) { require(!isAssetManager(_managers[i]), "addAssetManagers: Manager already registered"); accountToIsAssetManager[_managers[i]] = true; emit AssetManagerAdded(_managers[i]); } } /// @notice Claim ownership of the contract function claimOwnership() external { address nextOwner = nominatedOwner; require( msg.sender == nextOwner, "claimOwnership: Only the nominatedOwner can call this function" ); delete nominatedOwner; address prevOwner = owner; owner = nextOwner; emit OwnershipTransferred(prevOwner, nextOwner); } /// @notice Deregisters accounts that can manage vault holdings within the protocol /// @param _managers The accounts to remove as asset managers function removeAssetManagers(address[] calldata _managers) external onlyOwner { for (uint256 i; i < _managers.length; i++) { require(isAssetManager(_managers[i]), "removeAssetManagers: Manager not registered"); accountToIsAssetManager[_managers[i]] = false; emit AssetManagerRemoved(_managers[i]); } } /// @notice Revoke the nomination of a new contract owner function removeNominatedOwner() external onlyOwner { address removedNominatedOwner = nominatedOwner; require( removedNominatedOwner != address(0), "removeNominatedOwner: There is no nominated owner" ); delete nominatedOwner; emit NominatedOwnerRemoved(removedNominatedOwner); } /// @notice Sets the account that is allowed to migrate a fund to new releases /// @param _nextMigrator The account to set as the allowed migrator /// @dev Set to address(0) to remove the migrator. function setMigrator(address _nextMigrator) external onlyOwner { address prevMigrator = migrator; require(_nextMigrator != prevMigrator, "setMigrator: Value already set"); migrator = _nextMigrator; emit MigratorSet(prevMigrator, _nextMigrator); } /// @notice Nominate a new contract owner /// @param _nextNominatedOwner The account to nominate /// @dev Does not prohibit overwriting the current nominatedOwner function setNominatedOwner(address _nextNominatedOwner) external onlyOwner { require( _nextNominatedOwner != address(0), "setNominatedOwner: _nextNominatedOwner cannot be empty" ); require( _nextNominatedOwner != owner, "setNominatedOwner: _nextNominatedOwner is already the owner" ); require( _nextNominatedOwner != nominatedOwner, "setNominatedOwner: _nextNominatedOwner is already nominated" ); nominatedOwner = _nextNominatedOwner; emit NominatedOwnerSet(_nextNominatedOwner); } //////////////////////// // FUND DEPLOYER ONLY // //////////////////////// /// @notice Updates the accessor during a config change within this release /// @param _nextAccessor The next accessor function setAccessorForFundReconfiguration(address _nextAccessor) external override { require(msg.sender == getFundDeployer(), "Only the FundDeployer can make this call"); __setAccessor(_nextAccessor); } /////////////////////////////////////// // ACCESSOR (COMPTROLLER PROXY) ONLY // /////////////////////////////////////// /// @notice Adds a tracked asset /// @param _asset The asset to add as a tracked asset function addTrackedAsset(address _asset) external override onlyAccessor { __addTrackedAsset(_asset); } /// @notice Burns fund shares from a particular account /// @param _target The account for which to burn shares /// @param _amount The amount of shares to burn function burnShares(address _target, uint256 _amount) external override onlyAccessor { __burn(_target, _amount); } /// @notice Buys back shares collected as protocol fee at a discounted shares price, using MLN /// @param _sharesAmount The amount of shares to buy back /// @param _mlnValue The MLN-denominated market value of _sharesAmount /// @param _gav The total fund GAV /// @dev Since the vault controls both the MLN to burn and the admin function to burn any user's /// fund shares, there is no need to transfer assets back-and-forth with the ProtocolFeeReserve. /// We only need to know the correct discounted amount of MLN to burn. function buyBackProtocolFeeShares( uint256 _sharesAmount, uint256 _mlnValue, uint256 _gav ) external override onlyAccessor { uint256 mlnAmountToBurn = IProtocolFeeReserve1(getProtocolFeeReserve()) .buyBackSharesViaTrustedVaultProxy(_sharesAmount, _mlnValue, _gav); if (mlnAmountToBurn == 0) { return; } // Burn shares and MLN amounts // If shares or MLN balance is insufficient, will revert __burn(getProtocolFeeReserve(), _sharesAmount); if (getMlnBurner() == address(0)) { ERC20Burnable(getMlnToken()).burn(mlnAmountToBurn); } else { ERC20(getMlnToken()).safeTransfer(getMlnBurner(), mlnAmountToBurn); } emit ProtocolFeeSharesBoughtBack(_sharesAmount, _mlnValue, mlnAmountToBurn); } /// @notice Makes an arbitrary call with this contract as the sender /// @param _contract The contract to call /// @param _callData The call data for the call /// @return returnData_ The data returned by the call function callOnContract(address _contract, bytes calldata _callData) external override onlyAccessor returns (bytes memory returnData_) { bool success; (success, returnData_) = _contract.call(_callData); require(success, string(returnData_)); return returnData_; } /// @notice Mints fund shares to a particular account /// @param _target The account for which to burn shares /// @param _amount The amount of shares to mint function mintShares(address _target, uint256 _amount) external override onlyAccessor { __mint(_target, _amount); } /// @notice Pays the due protocol fee by minting shares to the ProtocolFeeReserve function payProtocolFee() external override onlyAccessor { uint256 sharesDue = IProtocolFeeTracker(getProtocolFeeTracker()).payFee(); if (sharesDue == 0) { return; } __mint(getProtocolFeeReserve(), sharesDue); emit ProtocolFeePaidInShares(sharesDue); } /// @notice Transfers fund shares from one account to another /// @param _from The account from which to transfer shares /// @param _to The account to which to transfer shares /// @param _amount The amount of shares to transfer /// @dev For protocol use only, all other transfers should operate /// via standard ERC20 functions function transferShares( address _from, address _to, uint256 _amount ) external override onlyAccessor { __transfer(_from, _to, _amount); } /// @notice Withdraws an asset from the VaultProxy to a given account /// @param _asset The asset to withdraw /// @param _target The account to which to withdraw the asset /// @param _amount The amount of asset to withdraw function withdrawAssetTo( address _asset, address _target, uint256 _amount ) external override onlyAccessor { __withdrawAssetTo(_asset, _target, _amount); } /////////////////////////// // VAULT ACTION DISPATCH // /////////////////////////// /// @notice Dispatches a call initiated from an Extension, validated by the ComptrollerProxy /// @param _action The VaultAction to perform /// @param _actionData The call data for the action to perform function receiveValidatedVaultAction(VaultAction _action, bytes calldata _actionData) external override onlyAccessor { if (_action == VaultAction.AddExternalPosition) { __executeVaultActionAddExternalPosition(_actionData); } else if (_action == VaultAction.AddTrackedAsset) { __executeVaultActionAddTrackedAsset(_actionData); } else if (_action == VaultAction.ApproveAssetSpender) { __executeVaultActionApproveAssetSpender(_actionData); } else if (_action == VaultAction.BurnShares) { __executeVaultActionBurnShares(_actionData); } else if (_action == VaultAction.CallOnExternalPosition) { __executeVaultActionCallOnExternalPosition(_actionData); } else if (_action == VaultAction.MintShares) { __executeVaultActionMintShares(_actionData); } else if (_action == VaultAction.RemoveExternalPosition) { __executeVaultActionRemoveExternalPosition(_actionData); } else if (_action == VaultAction.RemoveTrackedAsset) { __executeVaultActionRemoveTrackedAsset(_actionData); } else if (_action == VaultAction.TransferShares) { __executeVaultActionTransferShares(_actionData); } else if (_action == VaultAction.WithdrawAssetTo) { __executeVaultActionWithdrawAssetTo(_actionData); } } /// @dev Helper to decode actionData and execute VaultAction.AddExternalPosition function __executeVaultActionAddExternalPosition(bytes memory _actionData) private { __addExternalPosition(abi.decode(_actionData, (address))); } /// @dev Helper to decode actionData and execute VaultAction.AddTrackedAsset function __executeVaultActionAddTrackedAsset(bytes memory _actionData) private { __addTrackedAsset(abi.decode(_actionData, (address))); } /// @dev Helper to decode actionData and execute VaultAction.ApproveAssetSpender function __executeVaultActionApproveAssetSpender(bytes memory _actionData) private { (address asset, address target, uint256 amount) = abi.decode( _actionData, (address, address, uint256) ); __approveAssetSpender(asset, target, amount); } /// @dev Helper to decode actionData and execute VaultAction.BurnShares function __executeVaultActionBurnShares(bytes memory _actionData) private { (address target, uint256 amount) = abi.decode(_actionData, (address, uint256)); __burn(target, amount); } /// @dev Helper to decode actionData and execute VaultAction.CallOnExternalPosition function __executeVaultActionCallOnExternalPosition(bytes memory _actionData) private { ( address externalPosition, bytes memory callOnExternalPositionActionData, address[] memory assetsToTransfer, uint256[] memory amountsToTransfer, address[] memory assetsToReceive ) = abi.decode(_actionData, (address, bytes, address[], uint256[], address[])); __callOnExternalPosition( externalPosition, callOnExternalPositionActionData, assetsToTransfer, amountsToTransfer, assetsToReceive ); } /// @dev Helper to decode actionData and execute VaultAction.MintShares function __executeVaultActionMintShares(bytes memory _actionData) private { (address target, uint256 amount) = abi.decode(_actionData, (address, uint256)); __mint(target, amount); } /// @dev Helper to decode actionData and execute VaultAction.RemoveExternalPosition function __executeVaultActionRemoveExternalPosition(bytes memory _actionData) private { __removeExternalPosition(abi.decode(_actionData, (address))); } /// @dev Helper to decode actionData and execute VaultAction.RemoveTrackedAsset function __executeVaultActionRemoveTrackedAsset(bytes memory _actionData) private { __removeTrackedAsset(abi.decode(_actionData, (address))); } /// @dev Helper to decode actionData and execute VaultAction.TransferShares function __executeVaultActionTransferShares(bytes memory _actionData) private { (address from, address to, uint256 amount) = abi.decode( _actionData, (address, address, uint256) ); __transfer(from, to, amount); } /// @dev Helper to decode actionData and execute VaultAction.WithdrawAssetTo function __executeVaultActionWithdrawAssetTo(bytes memory _actionData) private { (address asset, address target, uint256 amount) = abi.decode( _actionData, (address, address, uint256) ); __withdrawAssetTo(asset, target, amount); } /////////////////// // VAULT ACTIONS // /////////////////// /// @dev Helper to track a new active external position function __addExternalPosition(address _externalPosition) private { if (!isActiveExternalPosition(_externalPosition)) { __validatePositionsLimit(); externalPositionToIsActive[_externalPosition] = true; activeExternalPositions.push(_externalPosition); emit ExternalPositionAdded(_externalPosition); } } /// @dev Helper to add a tracked asset function __addTrackedAsset(address _asset) private notShares(_asset) { if (!isTrackedAsset(_asset)) { __validatePositionsLimit(); assetToIsTracked[_asset] = true; trackedAssets.push(_asset); emit TrackedAssetAdded(_asset); } } /// @dev Helper to grant an allowance to a spender to use a vault asset function __approveAssetSpender( address _asset, address _target, uint256 _amount ) private notShares(_asset) { ERC20 assetContract = ERC20(_asset); if (assetContract.allowance(address(this), _target) > 0) { assetContract.safeApprove(_target, 0); } assetContract.safeApprove(_target, _amount); } /// @dev Helper to make a call on a external position contract /// @param _externalPosition The external position to call /// @param _actionData The action data for the call /// @param _assetsToTransfer The assets to transfer to the external position /// @param _amountsToTransfer The amount of assets to be transferred to the external position /// @param _assetsToReceive The assets that will be received from the call function __callOnExternalPosition( address _externalPosition, bytes memory _actionData, address[] memory _assetsToTransfer, uint256[] memory _amountsToTransfer, address[] memory _assetsToReceive ) private { require( isActiveExternalPosition(_externalPosition), "__callOnExternalPosition: Not an active external position" ); for (uint256 i; i < _assetsToTransfer.length; i++) { __withdrawAssetTo(_assetsToTransfer[i], _externalPosition, _amountsToTransfer[i]); } IExternalPosition(_externalPosition).receiveCallFromVault(_actionData); for (uint256 i; i < _assetsToReceive.length; i++) { __addTrackedAsset(_assetsToReceive[i]); } } /// @dev Helper to the get the Vault's balance of a given asset function __getAssetBalance(address _asset) private view returns (uint256 balance_) { return ERC20(_asset).balanceOf(address(this)); } /// @dev Helper to remove a external position from the vault function __removeExternalPosition(address _externalPosition) private { if (isActiveExternalPosition(_externalPosition)) { externalPositionToIsActive[_externalPosition] = false; activeExternalPositions.removeStorageItem(_externalPosition); emit ExternalPositionRemoved(_externalPosition); } } /// @dev Helper to remove a tracked asset function __removeTrackedAsset(address _asset) private { if (isTrackedAsset(_asset)) { assetToIsTracked[_asset] = false; trackedAssets.removeStorageItem(_asset); emit TrackedAssetRemoved(_asset); } } /// @dev Helper to validate that the positions limit has not been reached function __validatePositionsLimit() private view { require( trackedAssets.length + activeExternalPositions.length < getPositionsLimit(), "__validatePositionsLimit: Limit exceeded" ); } /// @dev Helper to withdraw an asset from the vault to a specified recipient function __withdrawAssetTo( address _asset, address _target, uint256 _amount ) private notShares(_asset) { ERC20(_asset).safeTransfer(_target, _amount); emit AssetWithdrawn(_asset, _target, _amount); } //////////////////////////// // SHARES ERC20 OVERRIDES // //////////////////////////// /// @notice Gets the `symbol` value of the shares token /// @return symbol_ The `symbol` value /// @dev Defers the shares symbol value to the Dispatcher contract if not set locally function symbol() public view override returns (string memory symbol_) { symbol_ = sharesSymbol; if (bytes(symbol_).length == 0) { symbol_ = IDispatcher(creator).getSharesTokenSymbol(); } return symbol_; } /// @dev Standard implementation of ERC20's transfer(). /// Overridden to allow arbitrary logic in ComptrollerProxy prior to transfer. function transfer(address _recipient, uint256 _amount) public override returns (bool success_) { __invokePreTransferSharesHook(msg.sender, _recipient, _amount); return super.transfer(_recipient, _amount); } /// @dev Standard implementation of ERC20's transferFrom(). /// Overridden to allow arbitrary logic in ComptrollerProxy prior to transfer. function transferFrom( address _sender, address _recipient, uint256 _amount ) public override returns (bool success_) { __invokePreTransferSharesHook(_sender, _recipient, _amount); return super.transferFrom(_sender, _recipient, _amount); } /// @dev Helper to call the relevant preTransferShares hook function __invokePreTransferSharesHook( address _sender, address _recipient, uint256 _amount ) private { if (sharesAreFreelyTransferable()) { IComptroller(accessor).preTransferSharesHookFreelyTransferable(_sender); } else { IComptroller(accessor).preTransferSharesHook(_sender, _recipient, _amount); } } /////////////////// // STATE GETTERS // /////////////////// /// @notice Checks whether an account can manage assets /// @param _who The account to check /// @return canManageAssets_ True if the account can manage assets function canManageAssets(address _who) external view override returns (bool canManageAssets_) { return _who == getOwner() || isAssetManager(_who); } /// @notice Checks whether an account can use gas relaying /// @param _who The account to check /// @return canRelayCalls_ True if the account can use gas relaying on this fund function canRelayCalls(address _who) external view override returns (bool canRelayCalls_) { return _who == getOwner() || isAssetManager(_who) || _who == getMigrator(); } /// @notice Gets the `accessor` variable /// @return accessor_ The `accessor` variable value function getAccessor() public view override returns (address accessor_) { return accessor; } /// @notice Gets the `creator` variable /// @return creator_ The `creator` variable value function getCreator() external view returns (address creator_) { return creator; } /// @notice Gets the `migrator` variable /// @return migrator_ The `migrator` variable value function getMigrator() public view returns (address migrator_) { return migrator; } /// @notice Gets the account that is nominated to be the next owner of this contract /// @return nominatedOwner_ The account that is nominated to be the owner function getNominatedOwner() external view returns (address nominatedOwner_) { return nominatedOwner; } /// @notice Gets the `activeExternalPositions` variable /// @return activeExternalPositions_ The `activeExternalPositions` variable value function getActiveExternalPositions() external view override returns (address[] memory activeExternalPositions_) { return activeExternalPositions; } /// @notice Gets the `trackedAssets` variable /// @return trackedAssets_ The `trackedAssets` variable value function getTrackedAssets() external view override returns (address[] memory trackedAssets_) { return trackedAssets; } // PUBLIC FUNCTIONS /// @notice Gets the `EXTERNAL_POSITION_MANAGER` variable /// @return externalPositionManager_ The `EXTERNAL_POSITION_MANAGER` variable value function getExternalPositionManager() public view returns (address externalPositionManager_) { return EXTERNAL_POSITION_MANAGER; } /// @notice Gets the vaults fund deployer /// @return fundDeployer_ The fund deployer contract associated with this vault function getFundDeployer() public view returns (address fundDeployer_) { return IDispatcher(creator).getFundDeployerForVaultProxy(address(this)); } /// @notice Gets the `MLN_BURNER` variable /// @return mlnBurner_ The `MLN_BURNER` variable value function getMlnBurner() public view returns (address mlnBurner_) { return MLN_BURNER; } /// @notice Gets the `MLN_TOKEN` variable /// @return mlnToken_ The `MLN_TOKEN` variable value function getMlnToken() public view returns (address mlnToken_) { return MLN_TOKEN; } /// @notice Gets the `owner` variable /// @return owner_ The `owner` variable value function getOwner() public view override returns (address owner_) { return owner; } /// @notice Gets the `POSITIONS_LIMIT` variable /// @return positionsLimit_ The `POSITIONS_LIMIT` variable value function getPositionsLimit() public view returns (uint256 positionsLimit_) { return POSITIONS_LIMIT; } /// @notice Gets the `PROTOCOL_FEE_RESERVE` variable /// @return protocolFeeReserve_ The `PROTOCOL_FEE_RESERVE` variable value function getProtocolFeeReserve() public view returns (address protocolFeeReserve_) { return PROTOCOL_FEE_RESERVE; } /// @notice Gets the `PROTOCOL_FEE_TRACKER` variable /// @return protocolFeeTracker_ The `PROTOCOL_FEE_TRACKER` variable value function getProtocolFeeTracker() public view returns (address protocolFeeTracker_) { return PROTOCOL_FEE_TRACKER; } /// @notice Check whether an external position is active on the vault /// @param _externalPosition The externalPosition to check /// @return isActiveExternalPosition_ True if the address is an active external position on the vault function isActiveExternalPosition(address _externalPosition) public view override returns (bool isActiveExternalPosition_) { return externalPositionToIsActive[_externalPosition]; } /// @notice Checks whether an account is an allowed asset manager /// @param _who The account to check /// @return isAssetManager_ True if the account is an allowed asset manager function isAssetManager(address _who) public view returns (bool isAssetManager_) { return accountToIsAssetManager[_who]; } /// @notice Checks whether an address is a tracked asset of the vault /// @param _asset The address to check /// @return isTrackedAsset_ True if the address is a tracked asset function isTrackedAsset(address _asset) public view override returns (bool isTrackedAsset_) { return assetToIsTracked[_asset]; } /// @notice Checks whether shares are (permanently) freely transferable /// @return sharesAreFreelyTransferable_ True if shares are (permanently) freely transferable function sharesAreFreelyTransferable() public view override returns (bool sharesAreFreelyTransferable_) { return freelyTransferableShares; } /// @notice Gets the `WETH_TOKEN` variable /// @return wethToken_ The `WETH_TOKEN` variable value function getWethToken() public view returns (address wethToken_) { return WETH_TOKEN; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IExtension Interface /// @author Enzyme Council <[email protected]> /// @notice Interface for all extensions interface IExtension { function activateForFund(bool _isMigration) external; function deactivateForFund() external; function receiveCallFromComptroller( address _caller, uint256 _actionId, bytes calldata _callArgs ) external; function setConfigForFund( address _comptrollerProxy, address _vaultProxy, bytes calldata _configData ) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IExternalPositionManager interface /// @author Enzyme Council <[email protected]> /// @notice Interface for the ExternalPositionManager interface IExternalPositionManager { struct ExternalPositionTypeInfo { address parser; address lib; } enum ExternalPositionManagerActions { CreateExternalPosition, CallOnExternalPosition, RemoveExternalPosition, ReactivateExternalPosition } function getExternalPositionLibForType(uint256) external view returns (address); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; /// @title FeeManager Interface /// @author Enzyme Council <[email protected]> /// @notice Interface for the FeeManager interface IFeeManager { // No fees for the current release are implemented post-redeemShares enum FeeHook {Continuous, PreBuyShares, PostBuyShares, PreRedeemShares} enum SettlementType {None, Direct, Mint, Burn, MintSharesOutstanding, BurnSharesOutstanding} function invokeHook( FeeHook, bytes calldata, uint256 ) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "./IPolicyManager.sol"; /// @title Policy Interface /// @author Enzyme Council <[email protected]> interface IPolicy { function activateForFund(address _comptrollerProxy) external; function addFundSettings(address _comptrollerProxy, bytes calldata _encodedSettings) external; function canDisable() external pure returns (bool canDisable_); function identifier() external pure returns (string memory identifier_); function implementedHooks() external pure returns (IPolicyManager.PolicyHook[] memory implementedHooks_); function updateFundSettings(address _comptrollerProxy, bytes calldata _encodedSettings) external; function validateRule( address _comptrollerProxy, IPolicyManager.PolicyHook _hook, bytes calldata _encodedArgs ) external returns (bool isValid_); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; /// @title PolicyManager Interface /// @author Enzyme Council <[email protected]> /// @notice Interface for the PolicyManager interface IPolicyManager { // When updating PolicyHook, also update these functions in PolicyManager: // 1. __getAllPolicyHooks() // 2. __policyHookRestrictsCurrentInvestorActions() enum PolicyHook { PostBuyShares, PostCallOnIntegration, PreTransferShares, RedeemSharesForSpecificAssets, AddTrackedAssets, RemoveTrackedAssets, CreateExternalPosition, PostCallOnExternalPosition, RemoveExternalPosition, ReactivateExternalPosition } function validatePolicies( address, PolicyHook, bytes calldata ) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "../../../../../persistent/address-list-registry/AddressListRegistry.sol"; import "../../../../core/fund/comptroller/ComptrollerLib.sol"; import "../utils/PolicyBase.sol"; /// @title AddressListRegistryPerUserPolicyBase Contract /// @author Enzyme Council <[email protected]> /// @notice Base contract inheritable by any policy that uses the AddressListRegistry and wants to track lists per fund user abstract contract AddressListRegistryPerUserPolicyBase is PolicyBase { event ListsSetForFundAndUser( address indexed comptrollerProxy, address indexed user, uint256[] listIds ); AddressListRegistry internal immutable ADDRESS_LIST_REGISTRY_CONTRACT; mapping(address => mapping(address => uint256[])) private comptrollerProxyToUserToListIds; constructor(address _policyUser, address _addressListRegistry) public PolicyBase(_policyUser) { ADDRESS_LIST_REGISTRY_CONTRACT = AddressListRegistry(_addressListRegistry); } // EXTERNAL FUNCTIONS /// @notice Adds the initial policy settings for a fund /// @param _comptrollerProxy The fund's ComptrollerProxy address /// @param _encodedSettings Encoded settings to apply to a fund function addFundSettings(address _comptrollerProxy, bytes calldata _encodedSettings) external virtual override onlyPolicyManager { __updateListsForFund(_comptrollerProxy, _encodedSettings); } // INTERNAL FUNCTIONS /// @dev Helper to set the lists to be used by a given fund and for specific users function __updateListsForFund(address _comptrollerProxy, bytes calldata _encodedSettings) internal { (address[] memory users, bytes[] memory listsData) = __decodePolicySettings( _encodedSettings ); require(users.length == listsData.length, "__updateListsForFund: unequal arrays"); for (uint256 i; i < listsData.length; i++) { __updateListsForFundAndUser(_comptrollerProxy, users[i], listsData[i]); } } // PRIVATE FUNCTIONS /// @dev Helper to create new list from encoded data function __createAddressListFromData(address _vaultProxy, bytes memory _newListData) private returns (uint256 listId_) { ( AddressListRegistry.UpdateType updateType, address[] memory initialItems ) = __decodeNewListData(_newListData); return ADDRESS_LIST_REGISTRY_CONTRACT.createList(_vaultProxy, updateType, initialItems); } /// @dev Helper to parse the args needed to create a new list function __decodeNewListData(bytes memory _newListData) private pure returns (AddressListRegistry.UpdateType updateType_, address[] memory initialItems_) { return abi.decode(_newListData, (AddressListRegistry.UpdateType, address[])); } /// @dev Helper to parse users and corresponding list data from encoded settings function __decodePolicySettings(bytes calldata _encodedSettings) private pure returns (address[] memory users_, bytes[] memory listsData_) { return abi.decode(_encodedSettings, (address[], bytes[])); } /// @dev Helper to parse the set of lists to be used for a given user function __decodeUserListsData(bytes memory _listData) private pure returns (uint256[] memory existingListIds_, bytes[] memory newListsData_) { return abi.decode(_listData, (uint256[], bytes[])); } /// @dev Helper to set the lists to be used by a given fund and user /// This is done in a simple manner rather than the most gas-efficient way possible /// (e.g., comparing already-stored items with an updated list would save on storage operations during updates). function __updateListsForFundAndUser( address _comptrollerProxy, address _user, bytes memory _listData ) private { (uint256[] memory existingListIds, bytes[] memory newListsData) = __decodeUserListsData( _listData ); // Clear the previously stored list ids as needed if (comptrollerProxyToUserToListIds[_comptrollerProxy][_user].length > 0) { delete comptrollerProxyToUserToListIds[_comptrollerProxy][_user]; } uint256[] memory nextListIds = new uint256[](existingListIds.length + newListsData.length); if (nextListIds.length > 0) { // Add existing list ids. // No need to validate existence, policy will just fail if out-of-bounds index. for (uint256 i; i < existingListIds.length; i++) { nextListIds[i] = existingListIds[i]; comptrollerProxyToUserToListIds[_comptrollerProxy][_user].push(existingListIds[i]); } // Create and add any new lists if (newListsData.length > 0) { address vaultProxy = ComptrollerLib(_comptrollerProxy).getVaultProxy(); for (uint256 i; i < newListsData.length; i++) { uint256 nextListIdsIndex = existingListIds.length + i; nextListIds[nextListIdsIndex] = __createAddressListFromData( vaultProxy, newListsData[i] ); comptrollerProxyToUserToListIds[_comptrollerProxy][_user].push( nextListIds[nextListIdsIndex] ); } } } emit ListsSetForFundAndUser(_comptrollerProxy, _user, nextListIds); } /////////////////// // STATE GETTERS // /////////////////// /// @notice Gets the list ids used by a given fund and user /// @param _comptrollerProxy The ComptrollerProxy of the fund /// @param _user The user of the fund /// @return listIds_ The list ids function getListIdsForFundAndUser(address _comptrollerProxy, address _user) public view returns (uint256[] memory listIds_) { return comptrollerProxyToUserToListIds[_comptrollerProxy][_user]; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; import "../../IPolicy.sol"; /// @title PolicyBase Contract /// @author Enzyme Council <[email protected]> /// @notice Abstract base contract for all policies abstract contract PolicyBase is IPolicy { address internal immutable POLICY_MANAGER; modifier onlyPolicyManager { require(msg.sender == POLICY_MANAGER, "Only the PolicyManager can make this call"); _; } constructor(address _policyManager) public { POLICY_MANAGER = _policyManager; } /// @notice Validates and initializes a policy as necessary prior to fund activation /// @dev Unimplemented by default, can be overridden by the policy function activateForFund(address) external virtual override { return; } /// @notice Whether or not the policy can be disabled /// @return canDisable_ True if the policy can be disabled /// @dev False by default, can be overridden by the policy function canDisable() external pure virtual override returns (bool canDisable_) { return false; } /// @notice Updates the policy settings for a fund /// @dev Disallowed by default, can be overridden by the policy function updateFundSettings(address, bytes calldata) external virtual override { revert("updateFundSettings: Updates not allowed for this policy"); } ////////////////////////////// // VALIDATION DATA DECODING // ////////////////////////////// /// @dev Helper to parse validation arguments from encoded data for AddTrackedAssets policy hook function __decodeAddTrackedAssetsValidationData(bytes memory _validationData) internal pure returns (address caller_, address[] memory assets_) { return abi.decode(_validationData, (address, address[])); } /// @dev Helper to parse validation arguments from encoded data for CreateExternalPosition policy hook function __decodeCreateExternalPositionValidationData(bytes memory _validationData) internal pure returns ( address caller_, uint256 typeId_, bytes memory initializationData_ ) { return abi.decode(_validationData, (address, uint256, bytes)); } /// @dev Helper to parse validation arguments from encoded data for PreTransferShares policy hook function __decodePreTransferSharesValidationData(bytes memory _validationData) internal pure returns ( address sender_, address recipient_, uint256 amount_ ) { return abi.decode(_validationData, (address, address, uint256)); } /// @dev Helper to parse validation arguments from encoded data for PostBuyShares policy hook function __decodePostBuySharesValidationData(bytes memory _validationData) internal pure returns ( address buyer_, uint256 investmentAmount_, uint256 sharesIssued_, uint256 gav_ ) { return abi.decode(_validationData, (address, uint256, uint256, uint256)); } /// @dev Helper to parse validation arguments from encoded data for PostCallOnExternalPosition policy hook function __decodePostCallOnExternalPositionValidationData(bytes memory _validationData) internal pure returns ( address caller_, address externalPosition_, address[] memory assetsToTransfer_, uint256[] memory amountsToTransfer_, address[] memory assetsToReceive_, bytes memory encodedActionData_ ) { return abi.decode( _validationData, (address, address, address[], uint256[], address[], bytes) ); } /// @dev Helper to parse validation arguments from encoded data for PostCallOnIntegration policy hook function __decodePostCallOnIntegrationValidationData(bytes memory _validationData) internal pure returns ( address caller_, address adapter_, bytes4 selector_, address[] memory incomingAssets_, uint256[] memory incomingAssetAmounts_, address[] memory spendAssets_, uint256[] memory spendAssetAmounts_ ) { return abi.decode( _validationData, (address, address, bytes4, address[], uint256[], address[], uint256[]) ); } /// @dev Helper to parse validation arguments from encoded data for ReactivateExternalPosition policy hook function __decodeReactivateExternalPositionValidationData(bytes memory _validationData) internal pure returns (address caller_, address externalPosition_) { return abi.decode(_validationData, (address, address)); } /// @dev Helper to parse validation arguments from encoded data for RedeemSharesForSpecificAssets policy hook function __decodeRedeemSharesForSpecificAssetsValidationData(bytes memory _validationData) internal pure returns ( address redeemer_, address recipient_, uint256 sharesToRedeemPostFees_, address[] memory assets_, uint256[] memory assetAmounts_, uint256 gavPreRedeem_ ) { return abi.decode( _validationData, (address, address, uint256, address[], uint256[], uint256) ); } /// @dev Helper to parse validation arguments from encoded data for RemoveExternalPosition policy hook function __decodeRemoveExternalPositionValidationData(bytes memory _validationData) internal pure returns (address caller_, address externalPosition_) { return abi.decode(_validationData, (address, address)); } /// @dev Helper to parse validation arguments from encoded data for RemoveTrackedAssets policy hook function __decodeRemoveTrackedAssetsValidationData(bytes memory _validationData) internal pure returns (address caller_, address[] memory assets_) { return abi.decode(_validationData, (address, address[])); } /////////////////// // STATE GETTERS // /////////////////// /// @notice Gets the `POLICY_MANAGER` variable value /// @return policyManager_ The `POLICY_MANAGER` variable value function getPolicyManager() external view returns (address policyManager_) { return POLICY_MANAGER; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ import "../../utils/beacon-proxy/IBeaconProxyFactory.sol"; import "./IGasRelayPaymaster.sol"; pragma solidity 0.6.12; /// @title GasRelayRecipientMixin Contract /// @author Enzyme Council <[email protected]> /// @notice A mixin that enables receiving GSN-relayed calls /// @dev IMPORTANT: Do not use storage var in this contract, /// unless it is no longer inherited by the VaultLib abstract contract GasRelayRecipientMixin { address internal immutable GAS_RELAY_PAYMASTER_FACTORY; constructor(address _gasRelayPaymasterFactory) internal { GAS_RELAY_PAYMASTER_FACTORY = _gasRelayPaymasterFactory; } /// @dev Helper to parse the canonical sender of a tx based on whether it has been relayed function __msgSender() internal view returns (address payable canonicalSender_) { if (msg.data.length >= 24 && msg.sender == getGasRelayTrustedForwarder()) { assembly { canonicalSender_ := shr(96, calldataload(sub(calldatasize(), 20))) } return canonicalSender_; } return msg.sender; } /////////////////// // STATE GETTERS // /////////////////// /// @notice Gets the `GAS_RELAY_PAYMASTER_FACTORY` variable /// @return gasRelayPaymasterFactory_ The `GAS_RELAY_PAYMASTER_FACTORY` variable value function getGasRelayPaymasterFactory() public view returns (address gasRelayPaymasterFactory_) { return GAS_RELAY_PAYMASTER_FACTORY; } /// @notice Gets the trusted forwarder for GSN relaying /// @return trustedForwarder_ The trusted forwarder function getGasRelayTrustedForwarder() public view returns (address trustedForwarder_) { return IGasRelayPaymaster( IBeaconProxyFactory(getGasRelayPaymasterFactory()).getCanonicalLib() ) .trustedForwarder(); } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import "../../interfaces/IGsnPaymaster.sol"; /// @title IGasRelayPaymaster Interface /// @author Enzyme Council <[email protected]> interface IGasRelayPaymaster is IGsnPaymaster { function deposit() external; function withdrawBalance() external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IGasRelayPaymasterDepositor Interface /// @author Enzyme Council <[email protected]> interface IGasRelayPaymasterDepositor { function pullWethForGasRelayer(uint256) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IProtocolFeeTracker Interface /// @author Enzyme Council <[email protected]> interface IProtocolFeeTracker { function initializeForVault(address) external; function payFee() external returns (uint256); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IValueInterpreter interface /// @author Enzyme Council <[email protected]> /// @notice Interface for ValueInterpreter interface IValueInterpreter { function calcCanonicalAssetValue( address, uint256, address ) external returns (uint256); function calcCanonicalAssetsTotalValue( address[] calldata, uint256[] calldata, address ) external returns (uint256); function isSupportedAsset(address) external view returns (bool); function isSupportedDerivativeAsset(address) external view returns (bool); function isSupportedPrimitiveAsset(address) external view returns (bool); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IGsnForwarder interface /// @author Enzyme Council <[email protected]> interface IGsnForwarder { struct ForwardRequest { address from; address to; uint256 value; uint256 gas; uint256 nonce; bytes data; uint256 validUntil; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import "./IGsnTypes.sol"; /// @title IGsnPaymaster interface /// @author Enzyme Council <[email protected]> interface IGsnPaymaster { struct GasAndDataLimits { uint256 acceptanceBudget; uint256 preRelayedCallGasLimit; uint256 postRelayedCallGasLimit; uint256 calldataSizeLimit; } function getGasAndDataLimits() external view returns (GasAndDataLimits memory limits); function getHubAddr() external view returns (address); function getRelayHubDeposit() external view returns (uint256); function preRelayedCall( IGsnTypes.RelayRequest calldata relayRequest, bytes calldata signature, bytes calldata approvalData, uint256 maxPossibleGas ) external returns (bytes memory context, bool rejectOnRecipientRevert); function postRelayedCall( bytes calldata context, bool success, uint256 gasUseWithoutPost, IGsnTypes.RelayData calldata relayData ) external; function trustedForwarder() external view returns (address); function versionPaymaster() external view returns (string memory); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; pragma experimental ABIEncoderV2; import "./IGsnForwarder.sol"; /// @title IGsnTypes Interface /// @author Enzyme Council <[email protected]> interface IGsnTypes { struct RelayData { uint256 gasPrice; uint256 pctRelayFee; uint256 baseRelayFee; address relayWorker; address paymaster; address forwarder; bytes paymasterData; uint256 clientId; } struct RelayRequest { IGsnForwarder.ForwardRequest request; RelayData relayData; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IWETH Interface /// @author Enzyme Council <[email protected]> interface IWETH { function deposit() external payable; function withdraw(uint256) external; }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title AddressArray Library /// @author Enzyme Council <[email protected]> /// @notice A library to extend the address array data type library AddressArrayLib { ///////////// // STORAGE // ///////////// /// @dev Helper to remove an item from a storage array function removeStorageItem(address[] storage _self, address _itemToRemove) internal returns (bool removed_) { uint256 itemCount = _self.length; for (uint256 i; i < itemCount; i++) { if (_self[i] == _itemToRemove) { if (i < itemCount - 1) { _self[i] = _self[itemCount - 1]; } _self.pop(); removed_ = true; break; } } return removed_; } /// @dev Helper to verify if a storage array contains a particular value function storageArrayContains(address[] storage _self, address _target) internal view returns (bool doesContain_) { uint256 arrLength = _self.length; for (uint256 i; i < arrLength; i++) { if (_target == _self[i]) { return true; } } return false; } //////////// // MEMORY // //////////// /// @dev Helper to add an item to an array. Does not assert uniqueness of the new item. function addItem(address[] memory _self, address _itemToAdd) internal pure returns (address[] memory nextArray_) { nextArray_ = new address[](_self.length + 1); for (uint256 i; i < _self.length; i++) { nextArray_[i] = _self[i]; } nextArray_[_self.length] = _itemToAdd; return nextArray_; } /// @dev Helper to add an item to an array, only if it is not already in the array. function addUniqueItem(address[] memory _self, address _itemToAdd) internal pure returns (address[] memory nextArray_) { if (contains(_self, _itemToAdd)) { return _self; } return addItem(_self, _itemToAdd); } /// @dev Helper to verify if an array contains a particular value function contains(address[] memory _self, address _target) internal pure returns (bool doesContain_) { for (uint256 i; i < _self.length; i++) { if (_target == _self[i]) { return true; } } return false; } /// @dev Helper to merge the unique items of a second array. /// Does not consider uniqueness of either array, only relative uniqueness. /// Preserves ordering. function mergeArray(address[] memory _self, address[] memory _arrayToMerge) internal pure returns (address[] memory nextArray_) { uint256 newUniqueItemCount; for (uint256 i; i < _arrayToMerge.length; i++) { if (!contains(_self, _arrayToMerge[i])) { newUniqueItemCount++; } } if (newUniqueItemCount == 0) { return _self; } nextArray_ = new address[](_self.length + newUniqueItemCount); for (uint256 i; i < _self.length; i++) { nextArray_[i] = _self[i]; } uint256 nextArrayIndex = _self.length; for (uint256 i; i < _arrayToMerge.length; i++) { if (!contains(_self, _arrayToMerge[i])) { nextArray_[nextArrayIndex] = _arrayToMerge[i]; nextArrayIndex++; } } return nextArray_; } /// @dev Helper to verify if array is a set of unique values. /// Does not assert length > 0. function isUniqueSet(address[] memory _self) internal pure returns (bool isUnique_) { if (_self.length <= 1) { return true; } uint256 arrayLength = _self.length; for (uint256 i; i < arrayLength; i++) { for (uint256 j = i + 1; j < arrayLength; j++) { if (_self[i] == _self[j]) { return false; } } } return true; } /// @dev Helper to remove items from an array. Removes all matching occurrences of each item. /// Does not assert uniqueness of either array. function removeItems(address[] memory _self, address[] memory _itemsToRemove) internal pure returns (address[] memory nextArray_) { if (_itemsToRemove.length == 0) { return _self; } bool[] memory indexesToRemove = new bool[](_self.length); uint256 remainingItemsCount = _self.length; for (uint256 i; i < _self.length; i++) { if (contains(_itemsToRemove, _self[i])) { indexesToRemove[i] = true; remainingItemsCount--; } } if (remainingItemsCount == _self.length) { nextArray_ = _self; } else if (remainingItemsCount > 0) { nextArray_ = new address[](remainingItemsCount); uint256 nextArrayIndex; for (uint256 i; i < _self.length; i++) { if (!indexesToRemove[i]) { nextArray_[nextArrayIndex] = _self[i]; nextArrayIndex++; } } } return nextArray_; } }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ pragma solidity 0.6.12; /// @title IBeacon interface /// @author Enzyme Council <[email protected]> interface IBeacon { function getCanonicalLib() external view returns (address); }
// SPDX-License-Identifier: GPL-3.0 /* This file is part of the Enzyme Protocol. (c) Enzyme Council <[email protected]> For the full license information, please view the LICENSE file that was distributed with this source code. */ import "./IBeacon.sol"; pragma solidity 0.6.12; /// @title IBeaconProxyFactory interface /// @author Enzyme Council <[email protected]> interface IBeaconProxyFactory is IBeacon { function deployProxy(bytes memory _constructData) external returns (address proxy_); function setCanonicalLib(address _canonicalLib) external; }
{ "evmVersion": "istanbul", "libraries": {}, "metadata": { "bytecodeHash": "ipfs", "useLiteralContent": true }, "optimizer": { "details": { "constantOptimizer": true, "cse": true, "deduplicate": true, "jumpdestRemover": true, "orderLiterals": true, "peephole": true, "yul": false }, "runs": 200 }, "remappings": [], "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_policyManager","type":"address"},{"internalType":"address","name":"_addressListRegistry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"comptrollerProxy","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"listIds","type":"uint256[]"}],"name":"ListsSetForFundAndUser","type":"event"},{"inputs":[],"name":"BYPASS_FLAG","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"activateForFund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_comptrollerProxy","type":"address"},{"internalType":"bytes","name":"_encodedSettings","type":"bytes"}],"name":"addFundSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"canDisable","outputs":[{"internalType":"bool","name":"canDisable_","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_comptrollerProxy","type":"address"},{"internalType":"address","name":"_user","type":"address"}],"name":"getListIdsForFundAndUser","outputs":[{"internalType":"uint256[]","name":"listIds_","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPolicyManager","outputs":[{"internalType":"address","name":"policyManager_","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"identifier","outputs":[{"internalType":"string","name":"identifier_","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"implementedHooks","outputs":[{"internalType":"enum IPolicyManager.PolicyHook[]","name":"implementedHooks_","type":"uint8[]"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_comptrollerProxy","type":"address"},{"internalType":"address","name":"_caller","type":"address"},{"internalType":"address","name":"_adapter","type":"address"}],"name":"passesRule","outputs":[{"internalType":"bool","name":"isValid_","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_comptrollerProxy","type":"address"},{"internalType":"bytes","name":"_encodedSettings","type":"bytes"}],"name":"updateFundSettings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_comptrollerProxy","type":"address"},{"internalType":"enum IPolicyManager.PolicyHook","name":"","type":"uint8"},{"internalType":"bytes","name":"_encodedArgs","type":"bytes"}],"name":"validateRule","outputs":[{"internalType":"bool","name":"isValid_","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
60c06040523480156200001157600080fd5b50604051620016e1380380620016e1833981016040819052620000349162000066565b6001600160601b0319606092831b8116608052911b1660a052620000d1565b80516200006081620000b7565b92915050565b600080604083850312156200007a57600080fd5b600062000088858562000053565b92505060206200009b8582860162000053565b9150509250929050565b60006001600160a01b03821662000060565b620000c281620000a5565b8114620000ce57600080fd5b50565b60805160601c60a05160601c6115dc62000105600039806104c8528061096b525080610199528061055f52506115dc6000f3fe608060405234801561001057600080fd5b50600436106100a95760003560e01c80637998a1c4116100715780637998a1c414610109578063b174666c1461011e578063cbf54bb21461013e578063ccdf1caf14610153578063ceb9a0ad14610166578063d44ad6cb14610179576100a9565b80630d4d7510146100ae5780630f5f6b4f146100ae5780631ef92578146100c3578063572a45e1146100e1578063579be718146100f6575b600080fd5b6100c16100bc366004610f48565b61018e565b005b6100cb6101ef565b6040516100d891906113db565b60405180910390f35b6100e96101f4565b6040516100d8919061141a565b6100cb610104366004610f9d565b6101fa565b61011161025d565b6040516100d891906113e9565b61013161012c366004610ec1565b610294565b6040516100d891906113aa565b61014661030c565b6040516100d89190611399565b6100cb610161366004610efb565b610363565b6100c1610174366004610d85565b61055a565b61018161055d565b6040516100d8919061135e565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146101df5760405162461bcd60e51b81526004016101d69061140a565b60405180910390fd5b6101ea838383610581565b505050565b600190565b60001981565b600080600061023e85858080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061060092505050565b505050505091509150610252878383610363565b979650505050505050565b60408051808201909152601c81527f414c4c4f5745445f41444150544552535f5045525f4d414e4147455200000000602082015290565b6001600160a01b038083166000908152602081815260408083209385168352928152908290208054835181840281018401909452808452606093928301828280156102fe57602002820191906000526020600020905b8154815260200190600101908083116102ea575b505050505090505b92915050565b6040805160018082528183019092526060916020808301908036833701905050905060018160008151811061033d57fe5b6020026020010190600981111561035057fe5b9081600981111561035d57fe5b90525090565b6000836001600160a01b031663c98091876040518163ffffffff1660e01b815260040160206040518083038186803b15801561039e57600080fd5b505afa1580156103b2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103d69190610dab565b6001600160a01b031663893d20e86040518163ffffffff1660e01b815260040160206040518083038186803b15801561040e57600080fd5b505afa158015610422573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104469190610dab565b6001600160a01b0316836001600160a01b0316141561046757506001610553565b60606104738585610294565b9050805160001415610489576000915050610553565b6000198160008151811061049957fe5b602002602001015114156104b1576001915050610553565b604051633ab3a7a360e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906375674f46906104ff90849087906004016113bb565b60206040518083038186803b15801561051757600080fd5b505afa15801561052b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061054f91906110be565b9150505b9392505050565b50565b7f000000000000000000000000000000000000000000000000000000000000000090565b60608061058e8484610636565b9150915080518251146105b35760405162461bcd60e51b81526004016101d6906113fa565b60005b81518110156105f8576105f0868483815181106105cf57fe5b60200260200101518484815181106105e357fe5b6020026020010151610651565b6001016105b6565b505050505050565b60008060006060806060808780602001905181019061061f9190610dc9565b959e949d50929b5090995097509550909350915050565b60608061064583850185611004565b915091505b9250929050565b60608061065d83610921565b6001600160a01b03808816600090815260208181526040808320938a16835292905220549193509150156106b9576001600160a01b0380861660009081526020818152604080832093881683529290529081206106b991610a17565b606081518351016001600160401b03811180156106d557600080fd5b506040519080825280602002602001820160405280156106ff578160200160208202803683370190505b508051909150156108ce5760005b83518110156107a15783818151811061072257fe5b602002602001015182828151811061073657fe5b6020908102919091018101919091526001600160a01b0380891660009081528083526040808220928a168252919092529020845185908390811061077657fe5b602090810291909101810151825460018181018555600094855292909320909201919091550161070d565b508151156108ce576000866001600160a01b031663c98091876040518163ffffffff1660e01b815260040160206040518083038186803b1580156107e457600080fd5b505afa1580156107f8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061081c9190610dab565b905060005b83518110156108cb57600081865101905061084f8386848151811061084257fe5b6020026020010151610941565b84828151811061085b57fe5b6020908102919091018101919091526001600160a01b03808b1660009081528083526040808220928c168252919092529020845185908390811061089b57fe5b60209081029190910181015182546001818101855560009485529290932090920191909155919091019050610821565b50505b846001600160a01b0316866001600160a01b03167fe737257df130e7ddcae83b49adac67dc3dcc32950b3e5ee558eae2f0b842a50f8360405161091191906113aa565b60405180910390a3505050505050565b606080828060200190518101906109389190611061565b91509150915091565b600080606061094f846109ff565b604051635f34203760e11b815291935091506001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063be68406e906109a49088908690869060040161136c565b602060405180830381600087803b1580156109be57600080fd5b505af11580156109d2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109f69190611123565b95945050505050565b600060608280602001905181019061093891906110dc565b508054600082559060005260206000209081019061055a91905b80821115610a455760008155600101610a31565b5090565b80356103068161155d565b80516103068161155d565b600082601f830112610a7057600080fd5b8135610a83610a7e8261144e565b611428565b91508181835260208401935060208101905083856020840282011115610aa857600080fd5b60005b83811015610ad45781610abe8882610a49565b8452506020928301929190910190600101610aab565b5050505092915050565b600082601f830112610aef57600080fd5b8151610afd610a7e8261144e565b91508181835260208401935060208101905083856020840282011115610b2257600080fd5b60005b83811015610ad45781610b388882610a54565b8452506020928301929190910190600101610b25565b600082601f830112610b5f57600080fd5b8135610b6d610a7e8261144e565b81815260209384019390925082018360005b83811015610ad45781358601610b958882610ccf565b8452506020928301929190910190600101610b7f565b600082601f830112610bbc57600080fd5b8151610bca610a7e8261144e565b81815260209384019390925082018360005b83811015610ad45781518601610bf28882610d1e565b8452506020928301929190910190600101610bdc565b600082601f830112610c1957600080fd5b8151610c27610a7e8261144e565b91508181835260208401935060208101905083856020840282011115610c4c57600080fd5b60005b83811015610ad45781610c628882610d7a565b8452506020928301929190910190600101610c4f565b805161030681611571565b80516103068161157a565b60008083601f840112610ca057600080fd5b5081356001600160401b03811115610cb757600080fd5b60208301915083600182028301111561064a57600080fd5b600082601f830112610ce057600080fd5b8135610cee610a7e8261146e565b91508082526020830160208301858383011115610d0a57600080fd5b610d15838284611503565b50505092915050565b600082601f830112610d2f57600080fd5b8151610d3d610a7e8261146e565b91508082526020830160208301858383011115610d5957600080fd5b610d1583828461150f565b803561030681611583565b805161030681611590565b80516103068161159d565b600060208284031215610d9757600080fd5b6000610da38484610a49565b949350505050565b600060208284031215610dbd57600080fd5b6000610da38484610a54565b600080600080600080600060e0888a031215610de457600080fd5b6000610df08a8a610a54565b9750506020610e018a828b01610a54565b9650506040610e128a828b01610c83565b95505060608801516001600160401b03811115610e2e57600080fd5b610e3a8a828b01610ade565b94505060808801516001600160401b03811115610e5657600080fd5b610e628a828b01610c08565b93505060a08801516001600160401b03811115610e7e57600080fd5b610e8a8a828b01610ade565b92505060c08801516001600160401b03811115610ea657600080fd5b610eb28a828b01610c08565b91505092959891949750929550565b60008060408385031215610ed457600080fd5b6000610ee08585610a49565b9250506020610ef185828601610a49565b9150509250929050565b600080600060608486031215610f1057600080fd5b6000610f1c8686610a49565b9350506020610f2d86828701610a49565b9250506040610f3e86828701610a49565b9150509250925092565b600080600060408486031215610f5d57600080fd5b6000610f698686610a49565b93505060208401356001600160401b03811115610f8557600080fd5b610f9186828701610c8e565b92509250509250925092565b60008060008060608587031215610fb357600080fd5b6000610fbf8787610a49565b9450506020610fd087828801610d64565b93505060408501356001600160401b03811115610fec57600080fd5b610ff887828801610c8e565b95989497509550505050565b6000806040838503121561101757600080fd5b82356001600160401b0381111561102d57600080fd5b61103985828601610a5f565b92505060208301356001600160401b0381111561105557600080fd5b610ef185828601610b4e565b6000806040838503121561107457600080fd5b82516001600160401b0381111561108a57600080fd5b61109685828601610c08565b92505060208301516001600160401b038111156110b257600080fd5b610ef185828601610bab565b6000602082840312156110d057600080fd5b6000610da38484610c78565b600080604083850312156110ef57600080fd5b60006110fb8585610d6f565b92505060208301516001600160401b0381111561111757600080fd5b610ef185828601610ade565b60006020828403121561113557600080fd5b6000610da38484610d7a565b600061114d838361116d565b505060200190565b600061114d838361127a565b600061114d8383611355565b611176816114a8565b82525050565b60006111878261149b565b611191818561149f565b935061119c83611495565b8060005b838110156111ca5781516111b48882611141565b97506111bf83611495565b9250506001016111a0565b509495945050505050565b60006111e08261149b565b6111ea818561149f565b93506111f583611495565b8060005b838110156111ca57815161120d8882611155565b975061121883611495565b9250506001016111f9565b600061122e8261149b565b611238818561149f565b935061124383611495565b8060005b838110156111ca57815161125b8882611161565b975061126683611495565b925050600101611247565b611176816114b3565b611176816114ed565b611176816114f8565b60006112978261149b565b6112a1818561149f565b93506112b181856020860161150f565b6112ba8161153f565b9093019392505050565b60006112d160248361149f565b7f5f5f7570646174654c69737473466f7246756e643a20756e657175616c2061728152637261797360e01b602082015260400192915050565b600061131760298361149f565b7f4f6e6c792074686520506f6c6963794d616e616765722063616e206d616b65208152681d1a1a5cc818d85b1b60ba1b602082015260400192915050565b611176816114ea565b60208101610306828461116d565b6060810161137a828661116d565b6113876020830185611283565b81810360408301526109f6818461117c565b6020808252810161055381846111d5565b602080825281016105538184611223565b604080825281016113cc8185611223565b9050610553602083018461116d565b602081016103068284611271565b60208082528101610553818461128c565b60208082528101610306816112c4565b602080825281016103068161130a565b602081016103068284611355565b6040518181016001600160401b038111828210171561144657600080fd5b604052919050565b60006001600160401b0382111561146457600080fd5b5060209081020190565b60006001600160401b0382111561148457600080fd5b506020601f91909101601f19160190565b60200190565b5190565b90815260200190565b6000610306826114de565b151590565b6001600160e01b03191690565b806114cf81611549565b919050565b806114cf81611553565b6001600160a01b031690565b90565b6000610306826114c5565b6000610306826114d4565b82818337506000910152565b60005b8381101561152a578181015183820152602001611512565b83811115611539576000848401525b50505050565b601f01601f191690565b600a811061055a57fe5b6004811061055a57fe5b611566816114a8565b811461055a57600080fd5b611566816114b3565b611566816114b8565b600a811061055a57600080fd5b6004811061055a57600080fd5b611566816114ea56fea264697066735822122049cc7a4d9905f12092bb829f5c9646dd91be921cfc3da3f323fe81187ac2be2e64736f6c634300060c00330000000000000000000000005a8ee0850d22ffef4169dbd348c1b0d7d5f5546f0000000000000000000000005ae15bf655a8f42b9c7d93e64f4476ec1da248f8
Deployed Bytecode
0x608060405234801561001057600080fd5b50600436106100a95760003560e01c80637998a1c4116100715780637998a1c414610109578063b174666c1461011e578063cbf54bb21461013e578063ccdf1caf14610153578063ceb9a0ad14610166578063d44ad6cb14610179576100a9565b80630d4d7510146100ae5780630f5f6b4f146100ae5780631ef92578146100c3578063572a45e1146100e1578063579be718146100f6575b600080fd5b6100c16100bc366004610f48565b61018e565b005b6100cb6101ef565b6040516100d891906113db565b60405180910390f35b6100e96101f4565b6040516100d8919061141a565b6100cb610104366004610f9d565b6101fa565b61011161025d565b6040516100d891906113e9565b61013161012c366004610ec1565b610294565b6040516100d891906113aa565b61014661030c565b6040516100d89190611399565b6100cb610161366004610efb565b610363565b6100c1610174366004610d85565b61055a565b61018161055d565b6040516100d8919061135e565b336001600160a01b037f0000000000000000000000005a8ee0850d22ffef4169dbd348c1b0d7d5f5546f16146101df5760405162461bcd60e51b81526004016101d69061140a565b60405180910390fd5b6101ea838383610581565b505050565b600190565b60001981565b600080600061023e85858080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061060092505050565b505050505091509150610252878383610363565b979650505050505050565b60408051808201909152601c81527f414c4c4f5745445f41444150544552535f5045525f4d414e4147455200000000602082015290565b6001600160a01b038083166000908152602081815260408083209385168352928152908290208054835181840281018401909452808452606093928301828280156102fe57602002820191906000526020600020905b8154815260200190600101908083116102ea575b505050505090505b92915050565b6040805160018082528183019092526060916020808301908036833701905050905060018160008151811061033d57fe5b6020026020010190600981111561035057fe5b9081600981111561035d57fe5b90525090565b6000836001600160a01b031663c98091876040518163ffffffff1660e01b815260040160206040518083038186803b15801561039e57600080fd5b505afa1580156103b2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103d69190610dab565b6001600160a01b031663893d20e86040518163ffffffff1660e01b815260040160206040518083038186803b15801561040e57600080fd5b505afa158015610422573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104469190610dab565b6001600160a01b0316836001600160a01b0316141561046757506001610553565b60606104738585610294565b9050805160001415610489576000915050610553565b6000198160008151811061049957fe5b602002602001015114156104b1576001915050610553565b604051633ab3a7a360e11b81526001600160a01b037f0000000000000000000000005ae15bf655a8f42b9c7d93e64f4476ec1da248f816906375674f46906104ff90849087906004016113bb565b60206040518083038186803b15801561051757600080fd5b505afa15801561052b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061054f91906110be565b9150505b9392505050565b50565b7f0000000000000000000000005a8ee0850d22ffef4169dbd348c1b0d7d5f5546f90565b60608061058e8484610636565b9150915080518251146105b35760405162461bcd60e51b81526004016101d6906113fa565b60005b81518110156105f8576105f0868483815181106105cf57fe5b60200260200101518484815181106105e357fe5b6020026020010151610651565b6001016105b6565b505050505050565b60008060006060806060808780602001905181019061061f9190610dc9565b959e949d50929b5090995097509550909350915050565b60608061064583850185611004565b915091505b9250929050565b60608061065d83610921565b6001600160a01b03808816600090815260208181526040808320938a16835292905220549193509150156106b9576001600160a01b0380861660009081526020818152604080832093881683529290529081206106b991610a17565b606081518351016001600160401b03811180156106d557600080fd5b506040519080825280602002602001820160405280156106ff578160200160208202803683370190505b508051909150156108ce5760005b83518110156107a15783818151811061072257fe5b602002602001015182828151811061073657fe5b6020908102919091018101919091526001600160a01b0380891660009081528083526040808220928a168252919092529020845185908390811061077657fe5b602090810291909101810151825460018181018555600094855292909320909201919091550161070d565b508151156108ce576000866001600160a01b031663c98091876040518163ffffffff1660e01b815260040160206040518083038186803b1580156107e457600080fd5b505afa1580156107f8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061081c9190610dab565b905060005b83518110156108cb57600081865101905061084f8386848151811061084257fe5b6020026020010151610941565b84828151811061085b57fe5b6020908102919091018101919091526001600160a01b03808b1660009081528083526040808220928c168252919092529020845185908390811061089b57fe5b60209081029190910181015182546001818101855560009485529290932090920191909155919091019050610821565b50505b846001600160a01b0316866001600160a01b03167fe737257df130e7ddcae83b49adac67dc3dcc32950b3e5ee558eae2f0b842a50f8360405161091191906113aa565b60405180910390a3505050505050565b606080828060200190518101906109389190611061565b91509150915091565b600080606061094f846109ff565b604051635f34203760e11b815291935091506001600160a01b037f0000000000000000000000005ae15bf655a8f42b9c7d93e64f4476ec1da248f8169063be68406e906109a49088908690869060040161136c565b602060405180830381600087803b1580156109be57600080fd5b505af11580156109d2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109f69190611123565b95945050505050565b600060608280602001905181019061093891906110dc565b508054600082559060005260206000209081019061055a91905b80821115610a455760008155600101610a31565b5090565b80356103068161155d565b80516103068161155d565b600082601f830112610a7057600080fd5b8135610a83610a7e8261144e565b611428565b91508181835260208401935060208101905083856020840282011115610aa857600080fd5b60005b83811015610ad45781610abe8882610a49565b8452506020928301929190910190600101610aab565b5050505092915050565b600082601f830112610aef57600080fd5b8151610afd610a7e8261144e565b91508181835260208401935060208101905083856020840282011115610b2257600080fd5b60005b83811015610ad45781610b388882610a54565b8452506020928301929190910190600101610b25565b600082601f830112610b5f57600080fd5b8135610b6d610a7e8261144e565b81815260209384019390925082018360005b83811015610ad45781358601610b958882610ccf565b8452506020928301929190910190600101610b7f565b600082601f830112610bbc57600080fd5b8151610bca610a7e8261144e565b81815260209384019390925082018360005b83811015610ad45781518601610bf28882610d1e565b8452506020928301929190910190600101610bdc565b600082601f830112610c1957600080fd5b8151610c27610a7e8261144e565b91508181835260208401935060208101905083856020840282011115610c4c57600080fd5b60005b83811015610ad45781610c628882610d7a565b8452506020928301929190910190600101610c4f565b805161030681611571565b80516103068161157a565b60008083601f840112610ca057600080fd5b5081356001600160401b03811115610cb757600080fd5b60208301915083600182028301111561064a57600080fd5b600082601f830112610ce057600080fd5b8135610cee610a7e8261146e565b91508082526020830160208301858383011115610d0a57600080fd5b610d15838284611503565b50505092915050565b600082601f830112610d2f57600080fd5b8151610d3d610a7e8261146e565b91508082526020830160208301858383011115610d5957600080fd5b610d1583828461150f565b803561030681611583565b805161030681611590565b80516103068161159d565b600060208284031215610d9757600080fd5b6000610da38484610a49565b949350505050565b600060208284031215610dbd57600080fd5b6000610da38484610a54565b600080600080600080600060e0888a031215610de457600080fd5b6000610df08a8a610a54565b9750506020610e018a828b01610a54565b9650506040610e128a828b01610c83565b95505060608801516001600160401b03811115610e2e57600080fd5b610e3a8a828b01610ade565b94505060808801516001600160401b03811115610e5657600080fd5b610e628a828b01610c08565b93505060a08801516001600160401b03811115610e7e57600080fd5b610e8a8a828b01610ade565b92505060c08801516001600160401b03811115610ea657600080fd5b610eb28a828b01610c08565b91505092959891949750929550565b60008060408385031215610ed457600080fd5b6000610ee08585610a49565b9250506020610ef185828601610a49565b9150509250929050565b600080600060608486031215610f1057600080fd5b6000610f1c8686610a49565b9350506020610f2d86828701610a49565b9250506040610f3e86828701610a49565b9150509250925092565b600080600060408486031215610f5d57600080fd5b6000610f698686610a49565b93505060208401356001600160401b03811115610f8557600080fd5b610f9186828701610c8e565b92509250509250925092565b60008060008060608587031215610fb357600080fd5b6000610fbf8787610a49565b9450506020610fd087828801610d64565b93505060408501356001600160401b03811115610fec57600080fd5b610ff887828801610c8e565b95989497509550505050565b6000806040838503121561101757600080fd5b82356001600160401b0381111561102d57600080fd5b61103985828601610a5f565b92505060208301356001600160401b0381111561105557600080fd5b610ef185828601610b4e565b6000806040838503121561107457600080fd5b82516001600160401b0381111561108a57600080fd5b61109685828601610c08565b92505060208301516001600160401b038111156110b257600080fd5b610ef185828601610bab565b6000602082840312156110d057600080fd5b6000610da38484610c78565b600080604083850312156110ef57600080fd5b60006110fb8585610d6f565b92505060208301516001600160401b0381111561111757600080fd5b610ef185828601610ade565b60006020828403121561113557600080fd5b6000610da38484610d7a565b600061114d838361116d565b505060200190565b600061114d838361127a565b600061114d8383611355565b611176816114a8565b82525050565b60006111878261149b565b611191818561149f565b935061119c83611495565b8060005b838110156111ca5781516111b48882611141565b97506111bf83611495565b9250506001016111a0565b509495945050505050565b60006111e08261149b565b6111ea818561149f565b93506111f583611495565b8060005b838110156111ca57815161120d8882611155565b975061121883611495565b9250506001016111f9565b600061122e8261149b565b611238818561149f565b935061124383611495565b8060005b838110156111ca57815161125b8882611161565b975061126683611495565b925050600101611247565b611176816114b3565b611176816114ed565b611176816114f8565b60006112978261149b565b6112a1818561149f565b93506112b181856020860161150f565b6112ba8161153f565b9093019392505050565b60006112d160248361149f565b7f5f5f7570646174654c69737473466f7246756e643a20756e657175616c2061728152637261797360e01b602082015260400192915050565b600061131760298361149f565b7f4f6e6c792074686520506f6c6963794d616e616765722063616e206d616b65208152681d1a1a5cc818d85b1b60ba1b602082015260400192915050565b611176816114ea565b60208101610306828461116d565b6060810161137a828661116d565b6113876020830185611283565b81810360408301526109f6818461117c565b6020808252810161055381846111d5565b602080825281016105538184611223565b604080825281016113cc8185611223565b9050610553602083018461116d565b602081016103068284611271565b60208082528101610553818461128c565b60208082528101610306816112c4565b602080825281016103068161130a565b602081016103068284611355565b6040518181016001600160401b038111828210171561144657600080fd5b604052919050565b60006001600160401b0382111561146457600080fd5b5060209081020190565b60006001600160401b0382111561148457600080fd5b506020601f91909101601f19160190565b60200190565b5190565b90815260200190565b6000610306826114de565b151590565b6001600160e01b03191690565b806114cf81611549565b919050565b806114cf81611553565b6001600160a01b031690565b90565b6000610306826114c5565b6000610306826114d4565b82818337506000910152565b60005b8381101561152a578181015183820152602001611512565b83811115611539576000848401525b50505050565b601f01601f191690565b600a811061055a57fe5b6004811061055a57fe5b611566816114a8565b811461055a57600080fd5b611566816114b3565b611566816114b8565b600a811061055a57600080fd5b6004811061055a57600080fd5b611566816114ea56fea264697066735822122049cc7a4d9905f12092bb829f5c9646dd91be921cfc3da3f323fe81187ac2be2e64736f6c634300060c0033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000005a8ee0850d22ffef4169dbd348c1b0d7d5f5546f0000000000000000000000005ae15bf655a8f42b9c7d93e64f4476ec1da248f8
-----Decoded View---------------
Arg [0] : _policyManager (address): 0x5a8Ee0850d22FfeF4169DbD348c1b0d7d5f5546F
Arg [1] : _addressListRegistry (address): 0x5AE15bF655a8f42b9C7D93E64f4476ec1DA248f8
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005a8ee0850d22ffef4169dbd348c1b0d7d5f5546f
Arg [1] : 0000000000000000000000005ae15bf655a8f42b9c7d93e64f4476ec1da248f8
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.