Feature Tip: Add private address tag to any address under My Name Tag !
More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 60 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Withdraw | 17364667 | 503 days ago | IN | 0 ETH | 0.0243223 | ||||
Withdraw | 17065575 | 546 days ago | IN | 0 ETH | 0.01881031 | ||||
Withdraw | 17056887 | 547 days ago | IN | 0 ETH | 0.01679365 | ||||
Withdraw | 16995403 | 556 days ago | IN | 0 ETH | 0.01230666 | ||||
Withdraw | 16992671 | 556 days ago | IN | 0 ETH | 0.01341045 | ||||
Withdraw | 16991207 | 556 days ago | IN | 0 ETH | 0.02005155 | ||||
Withdraw | 16989930 | 556 days ago | IN | 0 ETH | 0.02246138 | ||||
Withdraw | 16974457 | 559 days ago | IN | 0 ETH | 0.0112713 | ||||
Withdraw | 16968646 | 559 days ago | IN | 0 ETH | 0.01303156 | ||||
Withdraw | 16956597 | 561 days ago | IN | 0 ETH | 0.01205896 | ||||
Withdraw | 16950944 | 562 days ago | IN | 0 ETH | 0.01173872 | ||||
Withdraw | 16950934 | 562 days ago | IN | 0 ETH | 0.01414276 | ||||
Withdraw | 16928189 | 565 days ago | IN | 0 ETH | 0.01835915 | ||||
Withdraw | 16927226 | 565 days ago | IN | 0 ETH | 0.02094071 | ||||
Withdraw | 16924538 | 566 days ago | IN | 0 ETH | 0.01733585 | ||||
Withdraw | 16924518 | 566 days ago | IN | 0 ETH | 0.01546852 | ||||
Approve | 16885166 | 571 days ago | IN | 0 ETH | 0.00171058 | ||||
Approve | 16879969 | 572 days ago | IN | 0 ETH | 0.00042397 | ||||
Approve | 16879965 | 572 days ago | IN | 0 ETH | 0.00039471 | ||||
Approve | 16864607 | 574 days ago | IN | 0 ETH | 0.00094798 | ||||
Withdraw | 16828604 | 579 days ago | IN | 0 ETH | 0.01981331 | ||||
Withdraw | 16796548 | 584 days ago | IN | 0 ETH | 0.01496777 | ||||
Withdraw | 16793504 | 584 days ago | IN | 0 ETH | 0.03113677 | ||||
Approve | 16777559 | 586 days ago | IN | 0 ETH | 0.00198297 | ||||
Approve | 16771954 | 587 days ago | IN | 0 ETH | 0.00247804 |
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
16664758 | 602 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Minimal Proxy Contract for 0xa1eeeb677a121327ea2643fb47a23fec304edd00
Contract Name:
ERC20RootVault
Compiler Version
v0.8.9+commit.e5eed63a
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BSL-1.1 pragma solidity 0.8.9; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "../libraries/external/FullMath.sol"; import "../libraries/ExceptionsLibrary.sol"; import "../interfaces/vaults/IERC20RootVaultGovernance.sol"; import "../interfaces/vaults/IERC20RootVault.sol"; import "../interfaces/utils/ILpCallback.sol"; import "../utils/ERC20Token.sol"; import "./AggregateVault.sol"; import "../interfaces/utils/IERC20RootVaultHelper.sol"; /// @notice Contract that mints and burns LP tokens in exchange for ERC20 liquidity. contract ERC20RootVault is IERC20RootVault, ERC20Token, ReentrancyGuard, AggregateVault { using SafeERC20 for IERC20; using EnumerableSet for EnumerableSet.AddressSet; /// @inheritdoc IERC20RootVault uint64 public lastFeeCharge; /// @inheritdoc IERC20RootVault uint64 public totalWithdrawnAmountsTimestamp; /// @inheritdoc IERC20RootVault uint256[] public totalWithdrawnAmounts; /// @inheritdoc IERC20RootVault uint256 public lpPriceHighWaterMarkD18; EnumerableSet.AddressSet private _depositorsAllowlist; IERC20RootVaultHelper public helper; // ------------------- EXTERNAL, VIEW ------------------- /// @inheritdoc IERC20RootVault function depositorsAllowlist() external view returns (address[] memory) { return _depositorsAllowlist.values(); } /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, AggregateVault) returns (bool) { return super.supportsInterface(interfaceId) || type(IERC20RootVault).interfaceId == interfaceId; } // ------------------- EXTERNAL, MUTATING ------------------- /// @inheritdoc IERC20RootVault function addDepositorsToAllowlist(address[] calldata depositors) external { _requireAtLeastStrategy(); for (uint256 i = 0; i < depositors.length; i++) { _depositorsAllowlist.add(depositors[i]); } } /// @inheritdoc IERC20RootVault function removeDepositorsFromAllowlist(address[] calldata depositors) external { _requireAtLeastStrategy(); for (uint256 i = 0; i < depositors.length; i++) { _depositorsAllowlist.remove(depositors[i]); } } /// @inheritdoc IERC20RootVault function initialize( uint256 nft_, address[] memory vaultTokens_, address strategy_, uint256[] memory subvaultNfts_, IERC20RootVaultHelper helper_ ) external { _initialize(vaultTokens_, nft_, strategy_, subvaultNfts_); _initERC20(_getTokenName(bytes("Mellow Lp Token "), nft_), _getTokenName(bytes("MLP"), nft_)); uint256 len = vaultTokens_.length; totalWithdrawnAmounts = new uint256[](len); lastFeeCharge = uint64(block.timestamp); helper = helper_; } /// @inheritdoc IERC20RootVault function deposit( uint256[] memory tokenAmounts, uint256 minLpTokens, bytes memory vaultOptions ) external nonReentrant returns (uint256[] memory actualTokenAmounts) { require( !IERC20RootVaultGovernance(address(_vaultGovernance)).operatorParams().disableDeposit, ExceptionsLibrary.FORBIDDEN ); address[] memory tokens = _vaultTokens; uint256 supply = totalSupply; if (supply == 0) { for (uint256 i = 0; i < tokens.length; ++i) { require(tokenAmounts[i] >= 10 * _pullExistentials[i], ExceptionsLibrary.LIMIT_UNDERFLOW); require( tokenAmounts[i] <= _pullExistentials[i] * _pullExistentials[i], ExceptionsLibrary.LIMIT_OVERFLOW ); } } (uint256[] memory minTvl, uint256[] memory maxTvl) = tvl(); uint256 thisNft = _nft; _chargeFees(thisNft, minTvl, supply, tokens); supply = totalSupply; IERC20RootVaultGovernance.DelayedStrategyParams memory delayedStrategyParams = IERC20RootVaultGovernance( address(_vaultGovernance) ).delayedStrategyParams(thisNft); require( !delayedStrategyParams.privateVault || _depositorsAllowlist.contains(msg.sender), ExceptionsLibrary.FORBIDDEN ); uint256 preLpAmount; uint256[] memory normalizedAmounts = new uint256[](tokenAmounts.length); { bool isSignificantTvl; (preLpAmount, isSignificantTvl) = _getLpAmount(maxTvl, tokenAmounts, supply); for (uint256 i = 0; i < tokens.length; ++i) { normalizedAmounts[i] = _getNormalizedAmount( maxTvl[i], tokenAmounts[i], preLpAmount, supply, isSignificantTvl, _pullExistentials[i] ); IERC20(tokens[i]).safeTransferFrom(msg.sender, address(this), normalizedAmounts[i]); } } actualTokenAmounts = _push(normalizedAmounts, vaultOptions); (uint256 lpAmount, ) = _getLpAmount(maxTvl, actualTokenAmounts, supply); require(lpAmount >= minLpTokens, ExceptionsLibrary.LIMIT_UNDERFLOW); require(lpAmount != 0, ExceptionsLibrary.VALUE_ZERO); IERC20RootVaultGovernance.StrategyParams memory params = IERC20RootVaultGovernance(address(_vaultGovernance)) .strategyParams(thisNft); require(lpAmount + balanceOf[msg.sender] <= params.tokenLimitPerAddress, ExceptionsLibrary.LIMIT_OVERFLOW); require(lpAmount + supply <= params.tokenLimit, ExceptionsLibrary.LIMIT_OVERFLOW); // lock tokens on first deposit if (supply == 0) { _mint(address(0), lpAmount); } else { _mint(msg.sender, lpAmount); } for (uint256 i = 0; i < _vaultTokens.length; ++i) { if (normalizedAmounts[i] > actualTokenAmounts[i]) { IERC20(_vaultTokens[i]).safeTransfer(msg.sender, normalizedAmounts[i] - actualTokenAmounts[i]); } } if (delayedStrategyParams.depositCallbackAddress != address(0)) { try ILpCallback(delayedStrategyParams.depositCallbackAddress).depositCallback() {} catch Error( string memory reason ) { emit DepositCallbackLog(reason); } catch { emit DepositCallbackLog("callback failed without reason"); } } emit Deposit(msg.sender, _vaultTokens, actualTokenAmounts, lpAmount); } /// @inheritdoc IERC20RootVault function withdraw( address to, uint256 lpTokenAmount, uint256[] memory minTokenAmounts, bytes[] memory vaultsOptions ) external nonReentrant returns (uint256[] memory actualTokenAmounts) { uint256 supply = totalSupply; require(supply > 0, ExceptionsLibrary.VALUE_ZERO); address[] memory tokens = _vaultTokens; uint256[] memory tokenAmounts = new uint256[](_vaultTokens.length); (uint256[] memory minTvl, ) = tvl(); _chargeFees(_nft, minTvl, supply, tokens); supply = totalSupply; uint256 balance = balanceOf[msg.sender]; if (lpTokenAmount > balance) { lpTokenAmount = balance; } for (uint256 i = 0; i < tokens.length; ++i) { tokenAmounts[i] = FullMath.mulDiv(lpTokenAmount, minTvl[i], supply); } actualTokenAmounts = _pull(address(this), tokenAmounts, vaultsOptions); // we are draining balance // if no sufficent amounts rest bool sufficientAmountRest = false; for (uint256 i = 0; i < tokens.length; ++i) { require(actualTokenAmounts[i] >= minTokenAmounts[i], ExceptionsLibrary.LIMIT_UNDERFLOW); if (FullMath.mulDiv(balance, minTvl[i], supply) >= _pullExistentials[i] + actualTokenAmounts[i]) { sufficientAmountRest = true; } if (actualTokenAmounts[i] != 0) { IERC20(tokens[i]).safeTransfer(to, actualTokenAmounts[i]); } } _updateWithdrawnAmounts(actualTokenAmounts); if (sufficientAmountRest) { _burn(msg.sender, lpTokenAmount); } else { _burn(msg.sender, balance); } uint256 thisNft = _nft; IERC20RootVaultGovernance.DelayedStrategyParams memory delayedStrategyParams = IERC20RootVaultGovernance( address(_vaultGovernance) ).delayedStrategyParams(thisNft); if (delayedStrategyParams.withdrawCallbackAddress != address(0)) { try ILpCallback(delayedStrategyParams.withdrawCallbackAddress).withdrawCallback() {} catch Error( string memory reason ) { emit WithdrawCallbackLog(reason); } catch { emit WithdrawCallbackLog("callback failed without reason"); } } emit Withdraw(msg.sender, _vaultTokens, actualTokenAmounts, lpTokenAmount); } // ------------------- INTERNAL, VIEW ------------------- function _getLpAmount( uint256[] memory tvl_, uint256[] memory amounts, uint256 supply ) internal view returns (uint256 lpAmount, bool isSignificantTvl) { if (supply == 0) { // On init lpToken = max(tokenAmounts) for (uint256 i = 0; i < tvl_.length; ++i) { if (amounts[i] > lpAmount) { lpAmount = amounts[i]; } } return (lpAmount, false); } uint256 tvlsLength = tvl_.length; bool isLpAmountUpdated = false; uint256[] memory pullExistentials = _pullExistentials; for (uint256 i = 0; i < tvlsLength; ++i) { if (tvl_[i] < pullExistentials[i]) { continue; } uint256 tokenLpAmount = FullMath.mulDiv(amounts[i], supply, tvl_[i]); // take min of meaningful tokenLp amounts if ((tokenLpAmount < lpAmount) || (isLpAmountUpdated == false)) { isLpAmountUpdated = true; lpAmount = tokenLpAmount; } } isSignificantTvl = isLpAmountUpdated; // in case of almost zero tvl for all tokens -> do the same with supply == 0 if (!isSignificantTvl) { for (uint256 i = 0; i < tvl_.length; ++i) { if (amounts[i] > lpAmount) { lpAmount = amounts[i]; } } } } function _getNormalizedAmount( uint256 tvl_, uint256 amount, uint256 lpAmount, uint256 supply, bool isSignificantTvl, uint256 existentialsAmount ) internal pure returns (uint256) { if (supply == 0 || !isSignificantTvl) { // skip normalization on init return amount; } if (tvl_ < existentialsAmount) { // use zero-normalization when all tvls are dust-like return 0; } // normalize amount uint256 res = FullMath.mulDiv(tvl_, lpAmount, supply); if (res > amount) { res = amount; } return res; } function _requireAtLeastStrategy() internal view { uint256 nft_ = _nft; IVaultGovernance.InternalParams memory internalParams = _vaultGovernance.internalParams(); require( (internalParams.protocolGovernance.isAdmin(msg.sender) || internalParams.registry.getApproved(nft_) == msg.sender || (internalParams.registry.ownerOf(nft_) == msg.sender)), ExceptionsLibrary.FORBIDDEN ); } function _getTokenName(bytes memory prefix, uint256 nft_) internal pure returns (string memory) { bytes memory number = bytes(Strings.toString(nft_)); return string(abi.encodePacked(prefix, number)); } // ------------------- INTERNAL, MUTATING ------------------- /// @dev we are charging fees on the deposit / withdrawal /// fees are charged before the tokens transfer and change the balance of the lp tokens function _chargeFees( uint256 thisNft, uint256[] memory tvls, uint256 supply, address[] memory tokens ) internal { IERC20RootVaultGovernance vg = IERC20RootVaultGovernance(address(_vaultGovernance)); uint256 elapsed = block.timestamp - uint256(lastFeeCharge); IERC20RootVaultGovernance.DelayedProtocolParams memory delayedProtocolParams = vg.delayedProtocolParams(); if (elapsed < delayedProtocolParams.managementFeeChargeDelay) { return; } lastFeeCharge = uint64(block.timestamp); // don't charge on initial deposit if (supply == 0) { return; } { bool needSkip = true; uint256[] memory pullExistentials = _pullExistentials; for (uint256 i = 0; i < pullExistentials.length; ++i) { if (tvls[i] >= pullExistentials[i]) { needSkip = false; break; } } if (needSkip) { return; } } IERC20RootVaultGovernance.DelayedStrategyParams memory strategyParams = vg.delayedStrategyParams(thisNft); uint256 protocolFee = vg.delayedProtocolPerVaultParams(thisNft).protocolFee; address protocolTreasury = vg.internalParams().protocolGovernance.protocolTreasury(); _chargeManagementFees( strategyParams.managementFee, protocolFee, strategyParams.strategyTreasury, protocolTreasury, elapsed, supply ); _chargePerformanceFees( supply, tvls, strategyParams.performanceFee, strategyParams.strategyPerformanceTreasury, tokens, delayedProtocolParams.oracle ); } function _chargeManagementFees( uint256 managementFee, uint256 protocolFee, address strategyTreasury, address protocolTreasury, uint256 elapsed, uint256 lpSupply ) internal { if (managementFee > 0) { uint256 toMint = FullMath.mulDiv( managementFee * elapsed, lpSupply, CommonLibrary.YEAR * CommonLibrary.DENOMINATOR ); _mint(strategyTreasury, toMint); emit ManagementFeesCharged(strategyTreasury, managementFee, toMint); } if (protocolFee > 0) { uint256 toMint = FullMath.mulDiv( protocolFee * elapsed, lpSupply, CommonLibrary.YEAR * CommonLibrary.DENOMINATOR ); _mint(protocolTreasury, toMint); emit ProtocolFeesCharged(protocolTreasury, protocolFee, toMint); } } function _chargePerformanceFees( uint256 baseSupply, uint256[] memory baseTvls, uint256 performanceFee, address treasury, address[] memory tokens, IOracle oracle ) internal { if ((performanceFee == 0) || (baseSupply == 0)) { return; } uint256 tvlToken0 = helper.getTvlToken0(baseTvls, tokens, oracle); uint256 lpPriceD18 = FullMath.mulDiv(tvlToken0, CommonLibrary.D18, baseSupply); uint256 hwmsD18 = lpPriceHighWaterMarkD18; if (lpPriceD18 <= hwmsD18) { return; } uint256 toMint; if (hwmsD18 > 0) { toMint = FullMath.mulDiv(baseSupply, lpPriceD18 - hwmsD18, hwmsD18); toMint = FullMath.mulDiv(toMint, performanceFee, CommonLibrary.DENOMINATOR); _mint(treasury, toMint); } lpPriceHighWaterMarkD18 = lpPriceD18; emit PerformanceFeesCharged(treasury, performanceFee, toMint); } function _updateWithdrawnAmounts(uint256[] memory tokenAmounts) internal { uint256[] memory withdrawn = new uint256[](tokenAmounts.length); uint64 timestamp = uint64(block.timestamp); IProtocolGovernance protocolGovernance = _vaultGovernance.internalParams().protocolGovernance; if (timestamp != totalWithdrawnAmountsTimestamp) { totalWithdrawnAmountsTimestamp = timestamp; } else { for (uint256 i = 0; i < tokenAmounts.length; i++) { withdrawn[i] = totalWithdrawnAmounts[i]; } } for (uint256 i = 0; i < tokenAmounts.length; i++) { withdrawn[i] += tokenAmounts[i]; require( withdrawn[i] <= protocolGovernance.withdrawLimit(_vaultTokens[i]), ExceptionsLibrary.LIMIT_OVERFLOW ); totalWithdrawnAmounts[i] = withdrawn[i]; } } // -------------------------- EVENTS -------------------------- /// @notice Emitted when management fees are charged /// @param treasury Treasury receiver of the fee /// @param feeRate Fee percent applied denominated in 10 ** 9 /// @param amount Amount of lp token minted event ManagementFeesCharged(address indexed treasury, uint256 feeRate, uint256 amount); /// @notice Emitted when protocol fees are charged /// @param treasury Treasury receiver of the fee /// @param feeRate Fee percent applied denominated in 10 ** 9 /// @param amount Amount of lp token minted event ProtocolFeesCharged(address indexed treasury, uint256 feeRate, uint256 amount); /// @notice Emitted when performance fees are charged /// @param treasury Treasury receiver of the fee /// @param feeRate Fee percent applied denominated in 10 ** 9 /// @param amount Amount of lp token minted event PerformanceFeesCharged(address indexed treasury, uint256 feeRate, uint256 amount); /// @notice Emitted when liquidity is deposited /// @param from The source address for the liquidity /// @param tokens ERC20 tokens deposited /// @param actualTokenAmounts Token amounts deposited /// @param lpTokenMinted LP tokens received by the liquidity provider event Deposit(address indexed from, address[] tokens, uint256[] actualTokenAmounts, uint256 lpTokenMinted); /// @notice Emitted when liquidity is withdrawn /// @param from The source address for the liquidity /// @param tokens ERC20 tokens withdrawn /// @param actualTokenAmounts Token amounts withdrawn /// @param lpTokenBurned LP tokens burned from the liquidity provider event Withdraw(address indexed from, address[] tokens, uint256[] actualTokenAmounts, uint256 lpTokenBurned); /// @notice Emitted when callback in deposit failed /// @param reason Error reason event DepositCallbackLog(string reason); /// @notice Emitted when callback in withdraw failed /// @param reason Error reason event WithdrawCallbackLog(string reason); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (access/IAccessControlEnumerable.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; /** * @dev External interface of AccessControlEnumerable declared to support ERC165 detection. */ interface IAccessControlEnumerable is IAccessControl { /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) external view returns (address); /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (proxy/Clones.sol) pragma solidity ^0.8.0; /** * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for * deploying minimal proxy contracts, also known as "clones". * * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies * > a minimal bytecode implementation that delegates all calls to a known, fixed address. * * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2` * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the * deterministic method. * * _Available since v3.4._ */ library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create opcode, which should never revert. */ function clone(address implementation) internal returns (address instance) { assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create(0, ptr, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `implementation` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) { assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) instance := create2(0, ptr, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress( address implementation, bytes32 salt, address deployer ) internal pure returns (address predicted) { assembly { let ptr := mload(0x40) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(ptr, 0x14), shl(0x60, implementation)) mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000) mstore(add(ptr, 0x38), shl(0x60, deployer)) mstore(add(ptr, 0x4c), salt) mstore(add(ptr, 0x6c), keccak256(ptr, 0x37)) predicted := keccak256(add(ptr, 0x37), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress(address implementation, bytes32 salt) internal view returns (address predicted) { return predictDeterministicAddress(implementation, salt, address(this)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol) pragma solidity ^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 // OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.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 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' 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) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _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 require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/Address.sol) pragma solidity ^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; 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"); (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"); (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"); (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"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.0 (utils/structs/EnumerableSet.sol) pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { return _values(set._inner); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; assembly { result := store } return result; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "./utils/IDefaultAccessControl.sol"; import "./IUnitPricesGovernance.sol"; interface IProtocolGovernance is IDefaultAccessControl, IUnitPricesGovernance { /// @notice CommonLibrary protocol params. /// @param maxTokensPerVault Max different token addresses that could be managed by the vault /// @param governanceDelay The delay (in secs) that must pass before setting new pending params to commiting them /// @param protocolTreasury The address that collects protocolFees, if protocolFee is not zero /// @param forceAllowMask If a permission bit is set in this mask it forces all addresses to have this permission as true /// @param withdrawLimit Withdraw limit (in unit prices, i.e. usd) struct Params { uint256 maxTokensPerVault; uint256 governanceDelay; address protocolTreasury; uint256 forceAllowMask; uint256 withdrawLimit; } // ------------------- EXTERNAL, VIEW ------------------- /// @notice Timestamp after which staged granted permissions for the given address can be committed. /// @param target The given address /// @return Zero if there are no staged permission grants, timestamp otherwise function stagedPermissionGrantsTimestamps(address target) external view returns (uint256); /// @notice Staged granted permission bitmask for the given address. /// @param target The given address /// @return Bitmask function stagedPermissionGrantsMasks(address target) external view returns (uint256); /// @notice Permission bitmask for the given address. /// @param target The given address /// @return Bitmask function permissionMasks(address target) external view returns (uint256); /// @notice Timestamp after which staged pending protocol parameters can be committed /// @return Zero if there are no staged parameters, timestamp otherwise. function stagedParamsTimestamp() external view returns (uint256); /// @notice Staged pending protocol parameters. function stagedParams() external view returns (Params memory); /// @notice Current protocol parameters. function params() external view returns (Params memory); /// @notice Addresses for which non-zero permissions are set. function permissionAddresses() external view returns (address[] memory); /// @notice Permission addresses staged for commit. function stagedPermissionGrantsAddresses() external view returns (address[] memory); /// @notice Return all addresses where rawPermissionMask bit for permissionId is set to 1. /// @param permissionId Id of the permission to check. /// @return A list of dirty addresses. function addressesByPermission(uint8 permissionId) external view returns (address[] memory); /// @notice Checks if address has permission or given permission is force allowed for any address. /// @param addr Address to check /// @param permissionId Permission to check function hasPermission(address addr, uint8 permissionId) external view returns (bool); /// @notice Checks if address has all permissions. /// @param target Address to check /// @param permissionIds A list of permissions to check function hasAllPermissions(address target, uint8[] calldata permissionIds) external view returns (bool); /// @notice Max different ERC20 token addresses that could be managed by the protocol. function maxTokensPerVault() external view returns (uint256); /// @notice The delay for committing any governance params. function governanceDelay() external view returns (uint256); /// @notice The address of the protocol treasury. function protocolTreasury() external view returns (address); /// @notice Permissions mask which defines if ordinary permission should be reverted. /// This bitmask is xored with ordinary mask. function forceAllowMask() external view returns (uint256); /// @notice Withdraw limit per token per block. /// @param token Address of the token /// @return Withdraw limit per token per block function withdrawLimit(address token) external view returns (uint256); /// @notice Addresses that has staged validators. function stagedValidatorsAddresses() external view returns (address[] memory); /// @notice Timestamp after which staged granted permissions for the given address can be committed. /// @param target The given address /// @return Zero if there are no staged permission grants, timestamp otherwise function stagedValidatorsTimestamps(address target) external view returns (uint256); /// @notice Staged validator for the given address. /// @param target The given address /// @return Validator function stagedValidators(address target) external view returns (address); /// @notice Addresses that has validators. function validatorsAddresses() external view returns (address[] memory); /// @notice Address that has validators. /// @param i The number of address /// @return Validator address function validatorsAddress(uint256 i) external view returns (address); /// @notice Validator for the given address. /// @param target The given address /// @return Validator function validators(address target) external view returns (address); // ------------------- EXTERNAL, MUTATING, GOVERNANCE, IMMEDIATE ------------------- /// @notice Rollback all staged validators. function rollbackStagedValidators() external; /// @notice Revoke validator instantly from the given address. /// @param target The given address function revokeValidator(address target) external; /// @notice Stages a new validator for the given address /// @param target The given address /// @param validator The validator for the given address function stageValidator(address target, address validator) external; /// @notice Commits validator for the given address. /// @dev Reverts if governance delay has not passed yet. /// @param target The given address. function commitValidator(address target) external; /// @notice Commites all staged validators for which governance delay passed /// @return Addresses for which validators were committed function commitAllValidatorsSurpassedDelay() external returns (address[] memory); /// @notice Rollback all staged granted permission grant. function rollbackStagedPermissionGrants() external; /// @notice Commits permission grants for the given address. /// @dev Reverts if governance delay has not passed yet. /// @param target The given address. function commitPermissionGrants(address target) external; /// @notice Commites all staged permission grants for which governance delay passed. /// @return An array of addresses for which permission grants were committed. function commitAllPermissionGrantsSurpassedDelay() external returns (address[] memory); /// @notice Revoke permission instantly from the given address. /// @param target The given address. /// @param permissionIds A list of permission ids to revoke. function revokePermissions(address target, uint8[] memory permissionIds) external; /// @notice Commits staged protocol params. /// Reverts if governance delay has not passed yet. function commitParams() external; // ------------------- EXTERNAL, MUTATING, GOVERNANCE, DELAY ------------------- /// @notice Sets new pending params that could have been committed after governance delay expires. /// @param newParams New protocol parameters to set. function stageParams(Params memory newParams) external; /// @notice Stage granted permissions that could have been committed after governance delay expires. /// Resets commit delay and permissions if there are already staged permissions for this address. /// @param target Target address /// @param permissionIds A list of permission ids to grant function stagePermissionGrants(address target, uint8[] memory permissionIds) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "@openzeppelin/contracts/utils/introspection/IERC165.sol"; import "./utils/IDefaultAccessControl.sol"; interface IUnitPricesGovernance is IDefaultAccessControl, IERC165 { // ------------------- EXTERNAL, VIEW ------------------- /// @notice Estimated amount of token worth 1 USD staged for commit. /// @param token Address of the token /// @return The amount of token function stagedUnitPrices(address token) external view returns (uint256); /// @notice Timestamp after which staged unit prices for the given token can be committed. /// @param token Address of the token /// @return Timestamp function stagedUnitPricesTimestamps(address token) external view returns (uint256); /// @notice Estimated amount of token worth 1 USD. /// @param token Address of the token /// @return The amount of token function unitPrices(address token) external view returns (uint256); // ------------------- EXTERNAL, MUTATING ------------------- /// @notice Stage estimated amount of token worth 1 USD staged for commit. /// @param token Address of the token /// @param value The amount of token function stageUnitPrice(address token, uint256 value) external; /// @notice Reset staged value /// @param token Address of the token function rollbackUnitPrice(address token) external; /// @notice Commit staged unit price /// @param token Address of the token function commitUnitPrice(address token) external; }
// SPDX-License-Identifier: MIT pragma solidity =0.8.9; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "./IProtocolGovernance.sol"; interface IVaultRegistry is IERC721 { /// @notice Get Vault for the giver NFT ID. /// @param nftId NFT ID /// @return vault Address of the Vault contract function vaultForNft(uint256 nftId) external view returns (address vault); /// @notice Get NFT ID for given Vault contract address. /// @param vault Address of the Vault contract /// @return nftId NFT ID function nftForVault(address vault) external view returns (uint256 nftId); /// @notice Checks if the nft is locked for all transfers /// @param nft NFT to check for lock /// @return `true` if locked, false otherwise function isLocked(uint256 nft) external view returns (bool); /// @notice Register new Vault and mint NFT. /// @param vault address of the vault /// @param owner owner of the NFT /// @return nft Nft minted for the given Vault function registerVault(address vault, address owner) external returns (uint256 nft); /// @notice Number of Vaults registered. function vaultsCount() external view returns (uint256); /// @notice All Vaults registered. function vaults() external view returns (address[] memory); /// @notice Address of the ProtocolGovernance. function protocolGovernance() external view returns (IProtocolGovernance); /// @notice Address of the staged ProtocolGovernance. function stagedProtocolGovernance() external view returns (IProtocolGovernance); /// @notice Minimal timestamp when staged ProtocolGovernance can be applied. function stagedProtocolGovernanceTimestamp() external view returns (uint256); /// @notice Stage new ProtocolGovernance. /// @param newProtocolGovernance new ProtocolGovernance function stageProtocolGovernance(IProtocolGovernance newProtocolGovernance) external; /// @notice Commit new ProtocolGovernance. function commitStagedProtocolGovernance() external; /// @notice Lock NFT for transfers /// @dev Use this method when vault structure is set up and should become immutable. Can be called by owner. /// @param nft - NFT to lock function lockNft(uint256 nft) external; }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.8.9; library DataTypes { // refer to the whitepaper, section 1.1 basic concepts for a formal description of these properties. struct ReserveData { //stores the reserve configuration ReserveConfigurationMap configuration; //the liquidity index. Expressed in ray uint128 liquidityIndex; //variable borrow index. Expressed in ray uint128 variableBorrowIndex; //the current supply rate. Expressed in ray uint128 currentLiquidityRate; //the current variable borrow rate. Expressed in ray uint128 currentVariableBorrowRate; //the current stable borrow rate. Expressed in ray uint128 currentStableBorrowRate; uint40 lastUpdateTimestamp; //tokens addresses address aTokenAddress; address stableDebtTokenAddress; address variableDebtTokenAddress; //address of the interest rate strategy address interestRateStrategyAddress; //the id of the reserve. Represents the position in the list of the active reserves uint8 id; } struct ReserveConfigurationMap { //bit 0-15: LTV //bit 16-31: Liq. threshold //bit 32-47: Liq. bonus //bit 48-55: Decimals //bit 56: Reserve is active //bit 57: reserve is frozen //bit 58: borrowing is enabled //bit 59: stable rate borrowing enabled //bit 60-63: reserved //bit 64-79: reserve factor uint256 data; } struct UserConfigurationMap { uint256 data; } enum InterestRateMode { NONE, STABLE, VARIABLE } }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.8.9; pragma experimental ABIEncoderV2; import {ILendingPoolAddressesProvider} from "./ILendingPoolAddressesProvider.sol"; import {DataTypes} from "./DataTypes.sol"; interface ILendingPool { /** * @dev Emitted on deposit() * @param reserve The address of the underlying asset of the reserve * @param user The address initiating the deposit * @param onBehalfOf The beneficiary of the deposit, receiving the aTokens * @param amount The amount deposited * @param referral The referral code used **/ event Deposit( address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint16 indexed referral ); /** * @dev Emitted on withdraw() * @param reserve The address of the underlyng asset being withdrawn * @param user The address initiating the withdrawal, owner of aTokens * @param to Address that will receive the underlying * @param amount The amount to be withdrawn **/ event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount); /** * @dev Emitted on borrow() and flashLoan() when debt needs to be opened * @param reserve The address of the underlying asset being borrowed * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just * initiator of the transaction on flashLoan() * @param onBehalfOf The address that will be getting the debt * @param amount The amount borrowed out * @param borrowRateMode The rate mode: 1 for Stable, 2 for Variable * @param borrowRate The numeric rate at which the user has borrowed * @param referral The referral code used **/ event Borrow( address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint256 borrowRateMode, uint256 borrowRate, uint16 indexed referral ); /** * @dev Emitted on repay() * @param reserve The address of the underlying asset of the reserve * @param user The beneficiary of the repayment, getting his debt reduced * @param repayer The address of the user initiating the repay(), providing the funds * @param amount The amount repaid **/ event Repay(address indexed reserve, address indexed user, address indexed repayer, uint256 amount); /** * @dev Emitted on swapBorrowRateMode() * @param reserve The address of the underlying asset of the reserve * @param user The address of the user swapping his rate mode * @param rateMode The rate mode that the user wants to swap to **/ event Swap(address indexed reserve, address indexed user, uint256 rateMode); /** * @dev Emitted on setUserUseReserveAsCollateral() * @param reserve The address of the underlying asset of the reserve * @param user The address of the user enabling the usage as collateral **/ event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user); /** * @dev Emitted on setUserUseReserveAsCollateral() * @param reserve The address of the underlying asset of the reserve * @param user The address of the user enabling the usage as collateral **/ event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user); /** * @dev Emitted on rebalanceStableBorrowRate() * @param reserve The address of the underlying asset of the reserve * @param user The address of the user for which the rebalance has been executed **/ event RebalanceStableBorrowRate(address indexed reserve, address indexed user); /** * @dev Emitted on flashLoan() * @param target The address of the flash loan receiver contract * @param initiator The address initiating the flash loan * @param asset The address of the asset being flash borrowed * @param amount The amount flash borrowed * @param premium The fee flash borrowed * @param referralCode The referral code used **/ event FlashLoan( address indexed target, address indexed initiator, address indexed asset, uint256 amount, uint256 premium, uint16 referralCode ); /** * @dev Emitted when the pause is triggered. */ event Paused(); /** * @dev Emitted when the pause is lifted. */ event Unpaused(); /** * @dev Emitted when a borrower is liquidated. This event is emitted by the LendingPool via * LendingPoolCollateral manager using a DELEGATECALL * This allows to have the events in the generated ABI for LendingPool. * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation * @param user The address of the borrower getting liquidated * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover * @param liquidatedCollateralAmount The amount of collateral received by the liiquidator * @param liquidator The address of the liquidator * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants * to receive the underlying collateral asset directly **/ event LiquidationCall( address indexed collateralAsset, address indexed debtAsset, address indexed user, uint256 debtToCover, uint256 liquidatedCollateralAmount, address liquidator, bool receiveAToken ); /** * @dev Emitted when the state of a reserve is updated. NOTE: This event is actually declared * in the ReserveLogic library and emitted in the updateInterestRates() function. Since the function is internal, * the event will actually be fired by the LendingPool contract. The event is therefore replicated here so it * gets added to the LendingPool ABI * @param reserve The address of the underlying asset of the reserve * @param liquidityRate The new liquidity rate * @param stableBorrowRate The new stable borrow rate * @param variableBorrowRate The new variable borrow rate * @param liquidityIndex The new liquidity index * @param variableBorrowIndex The new variable borrow index **/ event ReserveDataUpdated( address indexed reserve, uint256 liquidityRate, uint256 stableBorrowRate, uint256 variableBorrowRate, uint256 liquidityIndex, uint256 variableBorrowIndex ); /** * @dev Deposits an `amount` of underlying asset into the reserve, receiving in return overlying aTokens. * - E.g. User deposits 100 USDC and gets in return 100 aUSDC * @param asset The address of the underlying asset to deposit * @param amount The amount to be deposited * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user * wants to receive them on his own wallet, or a different address if the beneficiary of aTokens * is a different wallet * @param referralCode Code used to register the integrator originating the operation, for potential rewards. * 0 if the action is executed directly by the user, without any middle-man **/ function deposit( address asset, uint256 amount, address onBehalfOf, uint16 referralCode ) external; /** * @dev Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC * @param asset The address of the underlying asset to withdraw * @param amount The underlying amount to be withdrawn * - Send the value type(uint256).max in order to withdraw the whole aToken balance * @param to Address that will receive the underlying, same as msg.sender if the user * wants to receive it on his own wallet, or a different address if the beneficiary is a * different wallet * @return The final amount withdrawn **/ function withdraw( address asset, uint256 amount, address to ) external returns (uint256); /** * @dev Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower * already deposited enough collateral, or he was given enough allowance by a credit delegator on the * corresponding debt token (StableDebtToken or VariableDebtToken) * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet * and 100 stable/variable debt tokens, depending on the `interestRateMode` * @param asset The address of the underlying asset to borrow * @param amount The amount to be borrowed * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable * @param referralCode Code used to register the integrator originating the operation, for potential rewards. * 0 if the action is executed directly by the user, without any middle-man * @param onBehalfOf Address of the user who will receive the debt. Should be the address of the borrower itself * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator * if he has been given credit delegation allowance **/ function borrow( address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf ) external; /** * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address * @param asset The address of the borrowed underlying asset previously borrowed * @param amount The amount to repay * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode` * @param rateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the * user calling the function if he wants to reduce/remove his own debt, or the address of any other * other borrower whose debt should be removed * @return The final amount repaid **/ function repay( address asset, uint256 amount, uint256 rateMode, address onBehalfOf ) external returns (uint256); /** * @dev Allows a borrower to swap his debt between stable and variable mode, or viceversa * @param asset The address of the underlying asset borrowed * @param rateMode The rate mode that the user wants to swap to **/ function swapBorrowRateMode(address asset, uint256 rateMode) external; /** * @dev Rebalances the stable interest rate of a user to the current stable rate defined on the reserve. * - Users can be rebalanced if the following conditions are satisfied: * 1. Usage ratio is above 95% * 2. the current deposit APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too much has been * borrowed at a stable rate and depositors are not earning enough * @param asset The address of the underlying asset borrowed * @param user The address of the user to be rebalanced **/ function rebalanceStableBorrowRate(address asset, address user) external; /** * @dev Allows depositors to enable/disable a specific deposited asset as collateral * @param asset The address of the underlying asset deposited * @param useAsCollateral `true` if the user wants to use the deposit as collateral, `false` otherwise **/ function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external; /** * @dev Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1 * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives * a proportionally amount of the `collateralAsset` plus a bonus to cover market risk * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation * @param user The address of the borrower getting liquidated * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover * @param receiveAToken `true` if the liquidators wants to receive the collateral aTokens, `false` if he wants * to receive the underlying collateral asset directly **/ function liquidationCall( address collateralAsset, address debtAsset, address user, uint256 debtToCover, bool receiveAToken ) external; /** * @dev Allows smartcontracts to access the liquidity of the pool within one transaction, * as long as the amount taken plus a fee is returned. * IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept into consideration. * For further details please visit https://developers.aave.com * @param receiverAddress The address of the contract receiving the funds, implementing the IFlashLoanReceiver interface * @param assets The addresses of the assets being flash-borrowed * @param amounts The amounts amounts being flash-borrowed * @param modes Types of the debt to open if the flash loan is not returned: * 0 -> Don't open any debt, just revert if funds can't be transferred from the receiver * 1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address * 2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address * @param onBehalfOf The address that will receive the debt in the case of using on `modes` 1 or 2 * @param params Variadic packed params to pass to the receiver as extra information * @param referralCode Code used to register the integrator originating the operation, for potential rewards. * 0 if the action is executed directly by the user, without any middle-man **/ function flashLoan( address receiverAddress, address[] calldata assets, uint256[] calldata amounts, uint256[] calldata modes, address onBehalfOf, bytes calldata params, uint16 referralCode ) external; /** * @dev Returns the user account data across all the reserves * @param user The address of the user * @return totalCollateralETH the total collateral in ETH of the user * @return totalDebtETH the total debt in ETH of the user * @return availableBorrowsETH the borrowing power left of the user * @return currentLiquidationThreshold the liquidation threshold of the user * @return ltv the loan to value of the user * @return healthFactor the current health factor of the user **/ function getUserAccountData(address user) external view returns ( uint256 totalCollateralETH, uint256 totalDebtETH, uint256 availableBorrowsETH, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor ); function initReserve( address reserve, address aTokenAddress, address stableDebtAddress, address variableDebtAddress, address interestRateStrategyAddress ) external; function setReserveInterestRateStrategyAddress(address reserve, address rateStrategyAddress) external; function setConfiguration(address reserve, uint256 configuration) external; /** * @dev Returns the configuration of the reserve * @param asset The address of the underlying asset of the reserve * @return The configuration of the reserve **/ function getConfiguration(address asset) external view returns (DataTypes.ReserveConfigurationMap memory); /** * @dev Returns the configuration of the user across all the reserves * @param user The user address * @return The configuration of the user **/ function getUserConfiguration(address user) external view returns (DataTypes.UserConfigurationMap memory); /** * @dev Returns the normalized income normalized income of the reserve * @param asset The address of the underlying asset of the reserve * @return The reserve's normalized income */ function getReserveNormalizedIncome(address asset) external view returns (uint256); /** * @dev Returns the normalized variable debt per unit of asset * @param asset The address of the underlying asset of the reserve * @return The reserve normalized variable debt */ function getReserveNormalizedVariableDebt(address asset) external view returns (uint256); /** * @dev Returns the state and configuration of the reserve * @param asset The address of the underlying asset of the reserve * @return The state of the reserve **/ function getReserveData(address asset) external view returns (DataTypes.ReserveData memory); function finalizeTransfer( address asset, address from, address to, uint256 amount, uint256 balanceFromAfter, uint256 balanceToBefore ) external; function getReservesList() external view returns (address[] memory); function getAddressesProvider() external view returns (ILendingPoolAddressesProvider); function setPause(bool val) external; function paused() external view returns (bool); }
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.8.9; /** * @title LendingPoolAddressesProvider contract * @dev Main registry of addresses part of or connected to the protocol, including permissioned roles * - Acting also as factory of proxies and admin of those, so with right to change its implementations * - Owned by the Aave Governance * @author Aave **/ interface ILendingPoolAddressesProvider { event MarketIdSet(string newMarketId); event LendingPoolUpdated(address indexed newAddress); event ConfigurationAdminUpdated(address indexed newAddress); event EmergencyAdminUpdated(address indexed newAddress); event LendingPoolConfiguratorUpdated(address indexed newAddress); event LendingPoolCollateralManagerUpdated(address indexed newAddress); event PriceOracleUpdated(address indexed newAddress); event LendingRateOracleUpdated(address indexed newAddress); event ProxyCreated(bytes32 id, address indexed newAddress); event AddressSet(bytes32 id, address indexed newAddress, bool hasProxy); function getMarketId() external view returns (string memory); function setMarketId(string calldata marketId) external; function setAddress(bytes32 id, address newAddress) external; function setAddressAsProxy(bytes32 id, address impl) external; function getAddress(bytes32 id) external view returns (address); function getLendingPool() external view returns (address); function setLendingPoolImpl(address pool) external; function getLendingPoolConfigurator() external view returns (address); function setLendingPoolConfiguratorImpl(address configurator) external; function getLendingPoolCollateralManager() external view returns (address); function setLendingPoolCollateralManager(address manager) external; function getPoolAdmin() external view returns (address); function setPoolAdmin(address admin) external; function getEmergencyAdmin() external view returns (address); function setEmergencyAdmin(address admin) external; function getPriceOracle() external view returns (address); function setPriceOracle(address priceOracle) external; function getLendingRateOracle() external view returns (address); function setLendingRateOracle(address lendingRateOracle) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface IERC1271 { /// @notice Verifies offchain signature. /// @dev Should return whether the signature provided is valid for the provided hash /// /// MUST return the bytes4 magic value 0x1626ba7e when function passes. /// /// MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5) /// /// MUST allow external calls /// @param _hash Hash of the data to be signed /// @param _signature Signature byte array associated with _hash /// @return magicValue 0x1626ba7e if valid, 0xffffffff otherwise function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4 magicValue); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface IOracle { /// @notice Oracle price for tokens as a Q64.96 value. /// @notice Returns pricing information based on the indexes of non-zero bits in safetyIndicesSet. /// @notice It is possible that not all indices will have their respective prices returned. /// @dev The price is token1 / token0 i.e. how many weis of token1 required for 1 wei of token0. /// The safety indexes are: /// /// 1 - unsafe, this is typically a spot price that can be easily manipulated, /// /// 2 - 4 - more or less safe, this is typically a uniV3 oracle, where the safety is defined by the timespan of the average price /// /// 5 - safe - this is typically a chailink oracle /// @param token0 Reference to token0 /// @param token1 Reference to token1 /// @param safetyIndicesSet Bitmask of safety indices that are allowed for the return prices. For set of safety indexes = { 1 }, safetyIndicesSet = 0x2 /// @return pricesX96 Prices that satisfy safetyIndex and tokens /// @return safetyIndices Safety indices for those prices function priceX96( address token0, address token1, uint256 safetyIndicesSet ) external view returns (uint256[] memory pricesX96, uint256[] memory safetyIndices); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "@openzeppelin/contracts/access/IAccessControlEnumerable.sol"; interface IDefaultAccessControl is IAccessControlEnumerable { /// @notice Checks that the address is contract admin. /// @param who Address to check /// @return `true` if who is admin, `false` otherwise function isAdmin(address who) external view returns (bool); /// @notice Checks that the address is contract admin. /// @param who Address to check /// @return `true` if who is operator, `false` otherwise function isOperator(address who) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../oracles/IOracle.sol"; interface IERC20RootVaultHelper { function getTvlToken0( uint256[] calldata tvls, address[] calldata tokens, IOracle oracle ) external view returns (uint256 tvl0); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface ILpCallback { /// @notice Function, that ERC20RootVault calling after deposit function depositCallback() external; /// @notice Function, that ERC20RootVault calling after withdraw function withdrawCallback() external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "./IVault.sol"; import "./IVaultRoot.sol"; interface IAggregateVault is IVault, IVaultRoot {}
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./IAggregateVault.sol"; import "../utils/IERC20RootVaultHelper.sol"; interface IERC20RootVault is IAggregateVault, IERC20 { /// @notice Initialized a new contract. /// @dev Can only be initialized by vault governance /// @param nft_ NFT of the vault in the VaultRegistry /// @param vaultTokens_ ERC20 tokens that will be managed by this Vault /// @param strategy_ The address that will have approvals for subvaultNfts /// @param subvaultNfts_ The NFTs of the subvaults that will be aggregated by this ERC20RootVault function initialize( uint256 nft_, address[] memory vaultTokens_, address strategy_, uint256[] memory subvaultNfts_, IERC20RootVaultHelper helper_ ) external; /// @notice The timestamp of last charging of fees function lastFeeCharge() external view returns (uint64); /// @notice The timestamp of last updating totalWithdrawnAmounts array function totalWithdrawnAmountsTimestamp() external view returns (uint64); /// @notice Returns value from totalWithdrawnAmounts array by _index /// @param _index The index at which the value will be returned function totalWithdrawnAmounts(uint256 _index) external view returns (uint256); /// @notice LP parameter that controls the charge in performance fees function lpPriceHighWaterMarkD18() external view returns (uint256); /// @notice List of addresses of depositors from which interaction with private vaults is allowed function depositorsAllowlist() external view returns (address[] memory); /// @notice Add new depositors in the depositorsAllowlist /// @param depositors Array of new depositors /// @dev The action can be done only by user with admins, owners or by approved rights function addDepositorsToAllowlist(address[] calldata depositors) external; /// @notice Remove depositors from the depositorsAllowlist /// @param depositors Array of depositors for remove /// @dev The action can be done only by user with admins, owners or by approved rights function removeDepositorsFromAllowlist(address[] calldata depositors) external; /// @notice The function of depositing the amount of tokens in exchange /// @param tokenAmounts Array of amounts of tokens for deposit /// @param minLpTokens Minimal value of LP tokens /// @param vaultOptions Options of vaults /// @return actualTokenAmounts Arrays of actual token amounts after deposit function deposit( uint256[] memory tokenAmounts, uint256 minLpTokens, bytes memory vaultOptions ) external returns (uint256[] memory actualTokenAmounts); /// @notice The function of withdrawing the amount of tokens in exchange /// @param to Address to which the withdrawal will be sent /// @param lpTokenAmount LP token amount, that requested for withdraw /// @param minTokenAmounts Array of minmal remining wtoken amounts after withdrawal /// @param vaultsOptions Options of vaults /// @return actualTokenAmounts Arrays of actual token amounts after withdrawal function withdraw( address to, uint256 lpTokenAmount, uint256[] memory minTokenAmounts, bytes[] memory vaultsOptions ) external returns (uint256[] memory actualTokenAmounts); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../oracles/IOracle.sol"; import "./IERC20RootVault.sol"; import "./IVaultGovernance.sol"; import "../utils/IERC20RootVaultHelper.sol"; interface IERC20RootVaultGovernance is IVaultGovernance { /// @notice Params that could be changed by Strategy or Protocol Governance with Protocol Governance delay. /// @param strategyTreasury Reference to address that will collect strategy management fees /// @param strategyPerformanceTreasury Reference to address that will collect strategy performance fees /// @param privateVault If true, only whitlisted depositors can deposit into the vault /// @param managementFee Management fee for Strategist denominated in 10 ** 9 /// @param performanceFee Performance fee for Strategist denominated in 10 ** 9 /// @param depositCallbackAddress Address of callback function after deposit /// @param withdrawCallbackAddress Address of callback function after withdraw struct DelayedStrategyParams { address strategyTreasury; address strategyPerformanceTreasury; bool privateVault; uint256 managementFee; uint256 performanceFee; address depositCallbackAddress; address withdrawCallbackAddress; } /// @notice Params that could be changed by Protocol Governance with Protocol Governance delay. /// @param managementFeeChargeDelay The minimal interval between management fee charges /// @param oracle Oracle for getting token prices struct DelayedProtocolParams { uint256 managementFeeChargeDelay; IOracle oracle; } /// @notice Params that could be changed by Strategy or Protocol Governance. /// @param tokenLimitPerAddress Max LP token limit per address /// @param tokenLimit Max LP token for the vault struct StrategyParams { uint256 tokenLimitPerAddress; uint256 tokenLimit; } /// @notice Params that could be changed by Protocol Governance with Protocol Governance delay. /// @param protocolFee Management fee for Protocol denominated in 10 ** 9 struct DelayedProtocolPerVaultParams { uint256 protocolFee; } /// @notice Params that could be changed by Operator role of Protocol Governance. /// @param disableDeposit Disable deposit for all ERC20 vaults struct OperatorParams { bool disableDeposit; } /// @notice Number of maximum protocol fee function MAX_PROTOCOL_FEE() external view returns (uint256); /// @notice Number of maximum management fee function MAX_MANAGEMENT_FEE() external view returns (uint256); /// @notice Number of maximum performance fee function MAX_PERFORMANCE_FEE() external view returns (uint256); /// @notice Delayed Protocol Params, i.e. Params that could be changed by Protocol Governance with Protocol Governance delay. function delayedProtocolParams() external view returns (DelayedProtocolParams memory); /// @notice Delayed Protocol Params staged for commit after delay. function stagedDelayedProtocolParams() external view returns (DelayedProtocolParams memory); /// @notice Delayed Protocol Per Vault Params, i.e. Params that could be changed by Protocol Governance with Protocol Governance delay. /// @param nft VaultRegistry NFT of the vault function delayedProtocolPerVaultParams(uint256 nft) external view returns (DelayedProtocolPerVaultParams memory); /// @notice Delayed Protocol Per Vault Params staged for commit after delay. /// @param nft VaultRegistry NFT of the vault function stagedDelayedProtocolPerVaultParams(uint256 nft) external view returns (DelayedProtocolPerVaultParams memory); /// @notice Strategy Params. /// @param nft VaultRegistry NFT of the vault function strategyParams(uint256 nft) external view returns (StrategyParams memory); /// @notice Operator Params. function operatorParams() external view returns (OperatorParams memory); /// @notice Delayed Strategy Params /// @param nft VaultRegistry NFT of the vault function delayedStrategyParams(uint256 nft) external view returns (DelayedStrategyParams memory); /// @notice Delayed Strategy Params staged for commit after delay. /// @param nft VaultRegistry NFT of the vault function stagedDelayedStrategyParams(uint256 nft) external view returns (DelayedStrategyParams memory); /// @notice Set Strategy params, i.e. Params that could be changed by Strategy or Protocol Governance immediately. /// @param nft Nft of the vault /// @param params New params function setStrategyParams(uint256 nft, StrategyParams calldata params) external; /// @notice Set Operator params, i.e. Params that could be changed by Operator or Protocol Governance immediately. /// @param params New params function setOperatorParams(OperatorParams calldata params) external; /// @notice Stage Delayed Protocol Per Vault Params, i.e. Params that could be changed by Protocol Governance with Protocol Governance delay. /// @param nft VaultRegistry NFT of the vault /// @param params New params function stageDelayedProtocolPerVaultParams(uint256 nft, DelayedProtocolPerVaultParams calldata params) external; /// @notice Commit Delayed Protocol Per Vault Params, i.e. Params that could be changed by Protocol Governance with Protocol Governance delay. /// @dev Can only be called after delayedProtocolPerVaultParamsTimestamp /// @param nft VaultRegistry NFT of the vault function commitDelayedProtocolPerVaultParams(uint256 nft) external; /// @notice Stage Delayed Strategy Params, i.e. Params that could be changed by Strategy or Protocol Governance with Protocol Governance delay. /// @param nft VaultRegistry NFT of the vault /// @param params New params function stageDelayedStrategyParams(uint256 nft, DelayedStrategyParams calldata params) external; /// @notice Commit Delayed Strategy Params, i.e. Params that could be changed by Strategy or Protocol Governance with Protocol Governance delay. /// @dev Can only be called after delayedStrategyParamsTimestamp /// @param nft VaultRegistry NFT of the vault function commitDelayedStrategyParams(uint256 nft) external; /// @notice Stage Delayed Protocol Params, i.e. Params that could be changed by Protocol Governance with Protocol Governance delay. /// @dev Can only be called after delayedProtocolParamsTimestamp. /// @param params New params function stageDelayedProtocolParams(DelayedProtocolParams calldata params) external; /// @notice Commit Delayed Protocol Params, i.e. Params that could be changed by Protocol Governance with Protocol Governance delay. function commitDelayedProtocolParams() external; /// @notice Deploys a new vault. /// @param vaultTokens_ ERC20 tokens that will be managed by this Vault /// @param strategy_ The address that will have approvals for subvaultNfts /// @param subvaultNfts_ The NFTs of the subvaults that will be aggregated by this ERC20RootVault /// @param owner_ Owner of the vault NFT function createVault( address[] memory vaultTokens_, address strategy_, uint256[] memory subvaultNfts_, address owner_ ) external returns (IERC20RootVault vault, uint256 nft); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../external/aave/ILendingPool.sol"; import "./IIntegrationVault.sol"; interface IERC20Vault is IIntegrationVault { /// @notice Initialized a new contract. /// @dev Can only be initialized by vault governance /// @param nft_ NFT of the vault in the VaultRegistry /// @param vaultTokens_ ERC20 tokens that will be managed by this Vault function initialize(uint256 nft_, address[] memory vaultTokens_) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../external/erc/IERC1271.sol"; import "./IVault.sol"; interface IIntegrationVault is IVault, IERC1271 { /// @notice Pushes tokens on the vault balance to the underlying protocol. For example, for Yearn this operation will take USDC from /// the contract balance and convert it to yUSDC. /// @dev Tokens **must** be a subset of Vault Tokens. However, the convention is that if tokenAmount == 0 it is the same as token is missing. /// /// Also notice that this operation doesn't guarantee that tokenAmounts will be invested in full. /// @param tokens Tokens to push /// @param tokenAmounts Amounts of tokens to push /// @param options Additional options that could be needed for some vaults. E.g. for Uniswap this could be `deadline` param. For the exact bytes structure see concrete vault descriptions /// @return actualTokenAmounts The amounts actually invested. It could be less than tokenAmounts (but not higher) function push( address[] memory tokens, uint256[] memory tokenAmounts, bytes memory options ) external returns (uint256[] memory actualTokenAmounts); /// @notice The same as `push` method above but transfers tokens to vault balance prior to calling push. /// After the `push` it returns all the leftover tokens back (`push` method doesn't guarantee that tokenAmounts will be invested in full). /// @param tokens Tokens to push /// @param tokenAmounts Amounts of tokens to push /// @param options Additional options that could be needed for some vaults. E.g. for Uniswap this could be `deadline` param. For the exact bytes structure see concrete vault descriptions /// @return actualTokenAmounts The amounts actually invested. It could be less than tokenAmounts (but not higher) function transferAndPush( address from, address[] memory tokens, uint256[] memory tokenAmounts, bytes memory options ) external returns (uint256[] memory actualTokenAmounts); /// @notice Pulls tokens from the underlying protocol to the `to` address. /// @dev Can only be called but Vault Owner or Strategy. Vault owner is the owner of NFT for this vault in VaultManager. /// Strategy is approved address for the vault NFT. /// When called by vault owner this method just pulls the tokens from the protocol to the `to` address /// When called by strategy on vault other than zero vault it pulls the tokens to zero vault (required `to` == zero vault) /// When called by strategy on zero vault it pulls the tokens to zero vault, pushes tokens on the `to` vault, and reclaims everything that's left. /// Thus any vault other than zero vault cannot have any tokens on it /// /// Tokens **must** be a subset of Vault Tokens. However, the convention is that if tokenAmount == 0 it is the same as token is missing. /// /// Pull is fulfilled on the best effort basis, i.e. if the tokenAmounts overflows available funds it withdraws all the funds. /// @param to Address to receive the tokens /// @param tokens Tokens to pull /// @param tokenAmounts Amounts of tokens to pull /// @param options Additional options that could be needed for some vaults. E.g. for Uniswap this could be `deadline` param. For the exact bytes structure see concrete vault descriptions /// @return actualTokenAmounts The amounts actually withdrawn. It could be less than tokenAmounts (but not higher) function pull( address to, address[] memory tokens, uint256[] memory tokenAmounts, bytes memory options ) external returns (uint256[] memory actualTokenAmounts); /// @notice Claim ERC20 tokens from vault balance to zero vault. /// @dev Cannot be called from zero vault. /// @param tokens Tokens to claim /// @return actualTokenAmounts Amounts reclaimed function reclaimTokens(address[] memory tokens) external returns (uint256[] memory actualTokenAmounts); /// @notice Execute one of whitelisted calls. /// @dev Can only be called by Vault Owner or Strategy. Vault owner is the owner of NFT for this vault in VaultManager. /// Strategy is approved address for the vault NFT. /// /// Since this method allows sending arbitrary transactions, the destinations of the calls /// are whitelisted by Protocol Governance. /// @param to Address of the reward pool /// @param selector Selector of the call /// @param data Abi encoded parameters to `to::selector` /// @return result Result of execution of the call function externalCall( address to, bytes4 selector, bytes memory data ) external payable returns (bytes memory result); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "./IVaultGovernance.sol"; interface IVault is IERC165 { /// @notice Checks if the vault is initialized function initialized() external view returns (bool); /// @notice VaultRegistry NFT for this vault function nft() external view returns (uint256); /// @notice Address of the Vault Governance for this contract. function vaultGovernance() external view returns (IVaultGovernance); /// @notice ERC20 tokens under Vault management. function vaultTokens() external view returns (address[] memory); /// @notice Checks if a token is vault token /// @param token Address of the token to check /// @return `true` if this token is managed by Vault function isVaultToken(address token) external view returns (bool); /// @notice Total value locked for this contract. /// @dev Generally it is the underlying token value of this contract in some /// other DeFi protocol. For example, for USDC Yearn Vault this would be total USDC balance that could be withdrawn for Yearn to this contract. /// The tvl itself is estimated in some range. Sometimes the range is exact, sometimes it's not /// @return minTokenAmounts Lower bound for total available balances estimation (nth tokenAmount corresponds to nth token in vaultTokens) /// @return maxTokenAmounts Upper bound for total available balances estimation (nth tokenAmount corresponds to nth token in vaultTokens) function tvl() external view returns (uint256[] memory minTokenAmounts, uint256[] memory maxTokenAmounts); /// @notice Existential amounts for each token function pullExistentials() external view returns (uint256[] memory); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../IProtocolGovernance.sol"; import "../IVaultRegistry.sol"; import "./IVault.sol"; interface IVaultGovernance { /// @notice Internal references of the contract. /// @param protocolGovernance Reference to Protocol Governance /// @param registry Reference to Vault Registry struct InternalParams { IProtocolGovernance protocolGovernance; IVaultRegistry registry; IVault singleton; } // ------------------- EXTERNAL, VIEW ------------------- /// @notice Timestamp in unix time seconds after which staged Delayed Strategy Params could be committed. /// @param nft Nft of the vault function delayedStrategyParamsTimestamp(uint256 nft) external view returns (uint256); /// @notice Timestamp in unix time seconds after which staged Delayed Protocol Params could be committed. function delayedProtocolParamsTimestamp() external view returns (uint256); /// @notice Timestamp in unix time seconds after which staged Delayed Protocol Params Per Vault could be committed. /// @param nft Nft of the vault function delayedProtocolPerVaultParamsTimestamp(uint256 nft) external view returns (uint256); /// @notice Timestamp in unix time seconds after which staged Internal Params could be committed. function internalParamsTimestamp() external view returns (uint256); /// @notice Internal Params of the contract. function internalParams() external view returns (InternalParams memory); /// @notice Staged new Internal Params. /// @dev The Internal Params could be committed after internalParamsTimestamp function stagedInternalParams() external view returns (InternalParams memory); // ------------------- EXTERNAL, MUTATING ------------------- /// @notice Stage new Internal Params. /// @param newParams New Internal Params function stageInternalParams(InternalParams memory newParams) external; /// @notice Commit staged Internal Params. function commitInternalParams() external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface IVaultRoot { /// @notice Checks if subvault is present /// @param nft_ index of subvault for check /// @return `true` if subvault present, `false` otherwise function hasSubvault(uint256 nft_) external view returns (bool); /// @notice Get subvault by index /// @param index Index of subvault /// @return address Address of the contract function subvaultAt(uint256 index) external view returns (address); /// @notice Get index of subvault by nft /// @param nft_ Nft for getting subvault /// @return index Index of subvault function subvaultOneBasedIndex(uint256 nft_) external view returns (uint256); /// @notice Get all subvalutNfts in the current Vault /// @return subvaultNfts Subvaults of NTFs function subvaultNfts() external view returns (uint256[] memory); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "./external/FullMath.sol"; import "./ExceptionsLibrary.sol"; /// @notice CommonLibrary shared utilities library CommonLibrary { uint256 constant DENOMINATOR = 10**9; uint256 constant D18 = 10**18; uint256 constant YEAR = 365 * 24 * 3600; uint256 constant Q128 = 2**128; uint256 constant Q96 = 2**96; uint256 constant Q48 = 2**48; uint256 constant Q160 = 2**160; uint256 constant UNI_FEE_DENOMINATOR = 10**6; /// @notice Sort uint256 using bubble sort. The sorting is done in-place. /// @param arr Array of uint256 function sortUint(uint256[] memory arr) internal pure { uint256 l = arr.length; for (uint256 i = 0; i < l; ++i) { for (uint256 j = i + 1; j < l; ++j) { if (arr[i] > arr[j]) { uint256 temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } } /// @notice Checks if array of addresses is sorted and all adresses are unique /// @param tokens A set of addresses to check /// @return `true` if all addresses are sorted and unique, `false` otherwise function isSortedAndUnique(address[] memory tokens) internal pure returns (bool) { if (tokens.length < 2) { return true; } for (uint256 i = 0; i < tokens.length - 1; ++i) { if (tokens[i] >= tokens[i + 1]) { return false; } } return true; } /// @notice Projects tokenAmounts onto subset or superset of tokens /// @dev /// Requires both sets of tokens to be sorted. When tokens are not sorted, it's undefined behavior. /// If there is a token in tokensToProject that is not part of tokens and corresponding tokenAmountsToProject > 0, reverts. /// Zero token amount is eqiuvalent to missing token function projectTokenAmounts( address[] memory tokens, address[] memory tokensToProject, uint256[] memory tokenAmountsToProject ) internal pure returns (uint256[] memory) { uint256[] memory res = new uint256[](tokens.length); uint256 t = 0; uint256 tp = 0; while ((t < tokens.length) && (tp < tokensToProject.length)) { if (tokens[t] < tokensToProject[tp]) { res[t] = 0; t++; } else if (tokens[t] > tokensToProject[tp]) { if (tokenAmountsToProject[tp] == 0) { tp++; } else { revert("TPS"); } } else { res[t] = tokenAmountsToProject[tp]; t++; tp++; } } while (t < tokens.length) { res[t] = 0; t++; } return res; } /// @notice Calculated sqrt of uint in X96 format /// @param xX96 input number in X96 format /// @return sqrt of xX96 in X96 format function sqrtX96(uint256 xX96) internal pure returns (uint256) { uint256 sqX96 = sqrt(xX96); return sqX96 << 48; } /// @notice Calculated sqrt of uint /// @param x input number /// @return sqrt of x function sqrt(uint256 x) internal pure returns (uint256) { if (x == 0) return 0; uint256 xx = x; uint256 r = 1; if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; } if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; } if (xx >= 0x100000000) { xx >>= 32; r <<= 16; } if (xx >= 0x10000) { xx >>= 16; r <<= 8; } if (xx >= 0x100) { xx >>= 8; r <<= 4; } if (xx >= 0x10) { xx >>= 4; r <<= 2; } if (xx >= 0x8) { r <<= 1; } r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; r = (r + x / r) >> 1; uint256 r1 = x / r; return (r < r1 ? r : r1); } /// @notice Recovers signer address from signed message hash /// @param _ethSignedMessageHash signed message /// @param _signature contatenated ECDSA r, s, v (65 bytes) /// @return Recovered address if the signature is valid, address(0) otherwise function recoverSigner(bytes32 _ethSignedMessageHash, bytes memory _signature) internal pure returns (address) { (bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature); return ecrecover(_ethSignedMessageHash, v, r, s); } /// @notice Get ECDSA r, s, v from signature /// @param sig signature (65 bytes) /// @return r ECDSA r /// @return s ECDSA s /// @return v ECDSA v function splitSignature(bytes memory sig) internal pure returns ( bytes32 r, bytes32 s, uint8 v ) { require(sig.length == 65, ExceptionsLibrary.INVALID_LENGTH); assembly { r := mload(add(sig, 32)) s := mload(add(sig, 64)) v := byte(0, mload(add(sig, 96))) } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; /// @notice Exceptions stores project`s smart-contracts exceptions library ExceptionsLibrary { string constant ADDRESS_ZERO = "AZ"; string constant VALUE_ZERO = "VZ"; string constant EMPTY_LIST = "EMPL"; string constant NOT_FOUND = "NF"; string constant INIT = "INIT"; string constant DUPLICATE = "DUP"; string constant NULL = "NULL"; string constant TIMESTAMP = "TS"; string constant FORBIDDEN = "FRB"; string constant ALLOWLIST = "ALL"; string constant LIMIT_OVERFLOW = "LIMO"; string constant LIMIT_UNDERFLOW = "LIMU"; string constant INVALID_VALUE = "INV"; string constant INVARIANT = "INVA"; string constant INVALID_TARGET = "INVTR"; string constant INVALID_TOKEN = "INVTO"; string constant INVALID_INTERFACE = "INVI"; string constant INVALID_SELECTOR = "INVS"; string constant INVALID_STATE = "INVST"; string constant INVALID_LENGTH = "INVL"; string constant LOCK = "LCKD"; string constant DISABLED = "DIS"; }
//SPDX-License-Identifier: MIT pragma solidity 0.8.9; /// @notice Stores permission ids for addresses library PermissionIdsLibrary { // The msg.sender is allowed to register vault uint8 constant REGISTER_VAULT = 0; // The msg.sender is allowed to create vaults uint8 constant CREATE_VAULT = 1; // The token is allowed to be transfered by vault uint8 constant ERC20_TRANSFER = 2; // The token is allowed to be added to vault uint8 constant ERC20_VAULT_TOKEN = 3; // Trusted protocols that are allowed to be approved of vault ERC20 tokens by any strategy uint8 constant ERC20_APPROVE = 4; // Trusted protocols that are allowed to be approved of vault ERC20 tokens by trusted strategy uint8 constant ERC20_APPROVE_RESTRICTED = 5; // Strategy allowed using restricted API uint8 constant TRUSTED_STRATEGY = 6; }
// SPDX-License-Identifier: MIT pragma solidity =0.8.9; /// @title Contains 512-bit math functions /// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision /// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits library FullMath { /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return result The 256-bit result /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv function mulDiv( uint256 a, uint256 b, uint256 denominator ) internal pure returns (uint256 result) { // diff: original lib works under 0.7.6 with overflows enabled unchecked { // 512-bit multiply [prod1 prod0] = a * b // Compute the product mod 2**256 and mod 2**256 - 1 // then use the Chinese Remainder Theorem to reconstruct // the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2**256 + prod0 uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(a, b, not(0)) prod0 := mul(a, b) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division if (prod1 == 0) { require(denominator > 0); assembly { result := div(prod0, denominator) } return result; } // Make sure the result is less than 2**256. // Also prevents denominator == 0 require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0] // Compute remainder using mulmod uint256 remainder; assembly { remainder := mulmod(a, b, denominator) } // Subtract 256 bit number from 512 bit number assembly { prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator // Compute largest power of two divisor of denominator. // Always >= 1. // diff: original uint256 twos = -denominator & denominator; uint256 twos = uint256(-int256(denominator)) & denominator; // Divide denominator by power of two assembly { denominator := div(denominator, twos) } // Divide [prod1 prod0] by the factors of two assembly { prod0 := div(prod0, twos) } // Shift in bits from prod1 into prod0. For this we need // to flip `twos` such that it is 2**256 / twos. // If twos is zero, then it becomes one assembly { twos := add(div(sub(0, twos), twos), 1) } prod0 |= prod1 * twos; // Invert denominator mod 2**256 // Now that denominator is an odd number, it has an inverse // modulo 2**256 such that denominator * inv = 1 mod 2**256. // Compute the inverse by starting with a seed that is correct // correct for four bits. That is, denominator * inv = 1 mod 2**4 uint256 inv = (3 * denominator) ^ 2; // Now use Newton-Raphson iteration to improve the precision. // Thanks to Hensel's lifting lemma, this also works in modular // arithmetic, doubling the correct bits in each step. inv *= 2 - denominator * inv; // inverse mod 2**8 inv *= 2 - denominator * inv; // inverse mod 2**16 inv *= 2 - denominator * inv; // inverse mod 2**32 inv *= 2 - denominator * inv; // inverse mod 2**64 inv *= 2 - denominator * inv; // inverse mod 2**128 inv *= 2 - denominator * inv; // inverse mod 2**256 // Because the division is now exact we can divide by multiplying // with the modular inverse of denominator. This will give us the // correct result modulo 2**256. Since the precoditions guarantee // that the outcome is less than 2**256, this is the final result. // We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inv; return result; } } /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 /// @param a The multiplicand /// @param b The multiplier /// @param denominator The divisor /// @return result The 256-bit result function mulDivRoundingUp( uint256 a, uint256 b, uint256 denominator ) internal pure returns (uint256 result) { // diff: original lib works under 0.7.6 with overflows enabled unchecked { result = mulDiv(a, b, denominator); if (mulmod(a, b, denominator) > 0) { require(result < type(uint256).max); result++; } } } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity =0.8.9; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "../libraries/ExceptionsLibrary.sol"; contract ERC20Token is IERC20 { bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); uint8 public constant decimals = 18; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; uint256 public totalSupply; string public name; string public symbol; uint256 private immutable _chainId; bytes32 private _cachedDomainSeparator; mapping(address => uint256) public nonces; constructor() { _chainId = block.chainid; } // ------------------- EXTERNAL, VIEW ------------------- function DOMAIN_SEPARATOR() public view virtual returns (bytes32) { return block.chainid == _chainId ? _cachedDomainSeparator : calculateDomainSeparator(); } // ------------------- EXTERNAL, MUTATING ------------------- function approve(address spender, uint256 amount) public virtual returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transfer(address to, uint256 amount) public virtual returns (bool) { balanceOf[msg.sender] -= amount; unchecked { balanceOf[to] += amount; } emit Transfer(msg.sender, to, amount); return true; } function transferFrom( address from, address to, uint256 amount ) public virtual returns (bool) { uint256 allowed = allowance[from][msg.sender]; if (allowed != type(uint256).max) { allowance[from][msg.sender] = allowed - amount; } balanceOf[from] -= amount; unchecked { balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual { require(deadline >= block.timestamp, ExceptionsLibrary.TIMESTAMP); unchecked { bytes32 digest = keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner], deadline)) ) ); nonces[owner] += 1; address recoveredAddress = ecrecover(digest, v, r, s); require(recoveredAddress != address(0) && recoveredAddress == owner, ExceptionsLibrary.FORBIDDEN); allowance[recoveredAddress][spender] = value; } emit Approval(owner, spender, value); } // ------------------- INTERNAL, VIEW ------------------- function calculateDomainSeparator() internal view virtual returns (bytes32) { return keccak256( abi.encode( keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(name)), keccak256("1"), block.chainid, address(this) ) ); } // ------------------- INTERNAL, MUTATING ------------------- function _initERC20(string memory _name, string memory _symbol) internal { name = _name; symbol = _symbol; _cachedDomainSeparator = calculateDomainSeparator(); } function _mint(address to, uint256 amount) internal virtual { totalSupply += amount; unchecked { balanceOf[to] += amount; } emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal virtual { balanceOf[from] -= amount; unchecked { totalSupply -= amount; } emit Transfer(from, address(0), amount); } }
// SPDX-License-Identifier: BSL-1.1 pragma solidity 0.8.9; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../interfaces/vaults/IIntegrationVault.sol"; import "../interfaces/vaults/IERC20Vault.sol"; import "../interfaces/vaults/IVaultRoot.sol"; import "../interfaces/vaults/IAggregateVault.sol"; import "./Vault.sol"; import "../libraries/ExceptionsLibrary.sol"; /// @notice Vault that combines several integration layer Vaults into one Vault. contract AggregateVault is IAggregateVault, Vault { using SafeERC20 for IERC20; uint256[] private _subvaultNfts; mapping(uint256 => uint256) private _subvaultNftsIndex; // ------------------- EXTERNAL, VIEW ------------------- /// @inheritdoc IVaultRoot function subvaultNfts() external view returns (uint256[] memory) { return _subvaultNfts; } /// @inheritdoc IVaultRoot function subvaultOneBasedIndex(uint256 nft_) external view returns (uint256) { return _subvaultNftsIndex[nft_]; } /// @inheritdoc IVaultRoot function hasSubvault(uint256 nft_) external view returns (bool) { return (_subvaultNftsIndex[nft_] > 0); } /// @inheritdoc IVaultRoot function subvaultAt(uint256 index) external view returns (address) { uint256 subvaultNft = _subvaultNfts[index]; return _vaultGovernance.internalParams().registry.vaultForNft(subvaultNft); } /// @inheritdoc IVault function tvl() public view override(IVault, Vault) returns (uint256[] memory minTokenAmounts, uint256[] memory maxTokenAmounts) { IVaultRegistry registry = _vaultGovernance.internalParams().registry; address[] memory vaultTokens = _vaultTokens; minTokenAmounts = new uint256[](vaultTokens.length); maxTokenAmounts = new uint256[](vaultTokens.length); for (uint256 i = 0; i < _subvaultNfts.length; ++i) { IIntegrationVault vault = IIntegrationVault(registry.vaultForNft(_subvaultNfts[i])); (uint256[] memory sMinTokenAmounts, uint256[] memory sMaxTokenAmounts) = vault.tvl(); address[] memory subvaultTokens = vault.vaultTokens(); uint256 subvaultTokenId = 0; for ( uint256 tokenId = 0; tokenId < vaultTokens.length && subvaultTokenId < subvaultTokens.length; ++tokenId ) { if (subvaultTokens[subvaultTokenId] == vaultTokens[tokenId]) { minTokenAmounts[tokenId] += sMinTokenAmounts[subvaultTokenId]; maxTokenAmounts[tokenId] += sMaxTokenAmounts[subvaultTokenId]; ++subvaultTokenId; } } } } /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, Vault) returns (bool) { return super.supportsInterface(interfaceId) || type(IAggregateVault).interfaceId == interfaceId; } // ------------------- INTERNAL, MUTATING ------------------- function _initialize( address[] memory vaultTokens_, uint256 nft_, address strategy_, uint256[] memory subvaultNfts_ ) internal virtual { IVaultRegistry vaultRegistry = IVaultGovernance(msg.sender).internalParams().registry; for (uint256 i = 0; i < subvaultNfts_.length; i++) { // Significant amount of checks has been done in ERC20RootVaultGovernance in the createVault function to reduce contract size uint256 subvaultNft = subvaultNfts_[i]; require(vaultRegistry.ownerOf(subvaultNft) == address(this), ExceptionsLibrary.FORBIDDEN); require(_subvaultNftsIndex[subvaultNft] == 0, ExceptionsLibrary.DUPLICATE); vaultRegistry.approve(strategy_, subvaultNft); vaultRegistry.lockNft(subvaultNft); _subvaultNftsIndex[subvaultNft] = i + 1; } _subvaultNfts = subvaultNfts_; _initialize(vaultTokens_, nft_); } function _push(uint256[] memory tokenAmounts, bytes memory vaultOptions) internal returns (uint256[] memory actualTokenAmounts) { require(_nft != 0, ExceptionsLibrary.INIT); IVaultGovernance.InternalParams memory params = _vaultGovernance.internalParams(); uint256 destNft = _subvaultNfts[0]; IVaultRegistry registry = params.registry; IIntegrationVault destVault = IIntegrationVault(registry.vaultForNft(destNft)); for (uint256 i = 0; i < _vaultTokens.length; i++) { if (tokenAmounts[i] > 0) { IERC20(_vaultTokens[i]).safeIncreaseAllowance(address(destVault), tokenAmounts[i]); } } actualTokenAmounts = destVault.transferAndPush(address(this), _vaultTokens, tokenAmounts, vaultOptions); for (uint256 i = 0; i < _vaultTokens.length; i++) { if (tokenAmounts[i] > 0) { IERC20(_vaultTokens[i]).safeApprove(address(destVault), 0); } } } function _pull( address to, uint256[] memory tokenAmounts, bytes[] memory vaultsOptions ) internal returns (uint256[] memory actualTokenAmounts) { require(_nft != 0, ExceptionsLibrary.INIT); require(vaultsOptions.length == _subvaultNfts.length, ExceptionsLibrary.INVALID_LENGTH); IVaultRegistry vaultRegistry = _vaultGovernance.internalParams().registry; actualTokenAmounts = new uint256[](tokenAmounts.length); address[] memory tokens = _vaultTokens; uint256[] memory existentials = _pullExistentials; uint256[] memory leftToPull = new uint256[](tokenAmounts.length); for (uint256 i = 0; i < tokens.length; i++) { leftToPull[i] = tokenAmounts[i]; } for (uint256 i = 0; i < _subvaultNfts.length; i++) { uint256 subvaultNft = _subvaultNfts[i]; IIntegrationVault subvault = IIntegrationVault(vaultRegistry.vaultForNft(subvaultNft)); uint256[] memory pulledAmounts = subvault.pull(address(this), tokens, leftToPull, vaultsOptions[i]); bool shouldStop = true; for (uint256 j = 0; j < tokens.length; j++) { if (leftToPull[j] > pulledAmounts[j] + existentials[j]) { shouldStop = false; leftToPull[j] -= pulledAmounts[j]; } else { leftToPull[j] = 0; } } if (shouldStop) { break; } } address subvault0 = vaultRegistry.vaultForNft(_subvaultNfts[0]); for (uint256 i = 0; i < tokens.length; i++) { uint256 balance = IERC20(tokens[i]).balanceOf(address(this)); if (tokenAmounts[i] < balance) { actualTokenAmounts[i] = tokenAmounts[i]; IERC20(tokens[i]).safeTransfer(to, tokenAmounts[i]); IERC20(tokens[i]).safeTransfer(subvault0, balance - tokenAmounts[i]); } else { actualTokenAmounts[i] = balance; IERC20(tokens[i]).safeTransfer(to, balance); } } } }
// SPDX-License-Identifier: BSL-1.1 pragma solidity 0.8.9; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; import "../libraries/CommonLibrary.sol"; import "../libraries/ExceptionsLibrary.sol"; import "../interfaces/vaults/IVault.sol"; import "./VaultGovernance.sol"; /// @notice Abstract contract that has logic common for every Vault. /// @dev Notes: /// ### ERC-721 /// /// Each Vault should be registered in VaultRegistry and get corresponding VaultRegistry NFT. /// /// ### Access control /// /// `push` and `pull` methods are only allowed for owner / approved person of the NFT. However, /// `pull` for approved person also checks that pull destination is another vault of the Vault System. /// /// The semantics is: NFT owner owns all Vault liquidity, Approved person is liquidity manager. /// ApprovedForAll person cannot do anything except ERC-721 token transfers. /// /// Both NFT owner and approved person can call externalCall method which claims liquidity mining rewards (if any) /// /// `reclaimTokens` for mistakenly transfered tokens (not included into vaultTokens) additionally can be withdrawn by /// the protocol admin abstract contract Vault is IVault, ERC165 { using SafeERC20 for IERC20; IVaultGovernance internal _vaultGovernance; address[] internal _vaultTokens; mapping(address => int256) internal _vaultTokensIndex; uint256 internal _nft; uint256[] internal _pullExistentials; constructor() { // lock initialization and thus all mutations for any deployed Vault _nft = type(uint256).max; } // ------------------- EXTERNAL, VIEW ------------------- /// @inheritdoc IVault function initialized() external view returns (bool) { return _nft != 0; } /// @inheritdoc IVault function isVaultToken(address token) public view returns (bool) { return _vaultTokensIndex[token] != 0; } /// @inheritdoc IVault function vaultGovernance() external view returns (IVaultGovernance) { return _vaultGovernance; } /// @inheritdoc IVault function vaultTokens() external view returns (address[] memory) { return _vaultTokens; } /// @inheritdoc IVault function nft() external view returns (uint256) { return _nft; } /// @inheritdoc IVault function tvl() public view virtual returns (uint256[] memory minTokenAmounts, uint256[] memory maxTokenAmounts); /// @inheritdoc IVault function pullExistentials() external view returns (uint256[] memory) { return _pullExistentials; } /// @inheritdoc IERC165 function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return super.supportsInterface(interfaceId) || (interfaceId == type(IVault).interfaceId); } // ------------------- INTERNAL, MUTATING ------------------- function _initialize(address[] memory vaultTokens_, uint256 nft_) internal virtual { require(_nft == 0, ExceptionsLibrary.INIT); require(CommonLibrary.isSortedAndUnique(vaultTokens_), ExceptionsLibrary.INVARIANT); require(nft_ != 0, ExceptionsLibrary.VALUE_ZERO); // guarantees that this method can only be called once IProtocolGovernance governance = IVaultGovernance(msg.sender).internalParams().protocolGovernance; require( vaultTokens_.length > 0 && vaultTokens_.length <= governance.maxTokensPerVault(), ExceptionsLibrary.INVALID_VALUE ); for (uint256 i = 0; i < vaultTokens_.length; i++) { require( governance.hasPermission(vaultTokens_[i], PermissionIdsLibrary.ERC20_VAULT_TOKEN), ExceptionsLibrary.FORBIDDEN ); } _vaultGovernance = IVaultGovernance(msg.sender); _vaultTokens = vaultTokens_; _nft = nft_; uint256 len = _vaultTokens.length; for (uint256 i = 0; i < len; ++i) { _vaultTokensIndex[vaultTokens_[i]] = int256(i + 1); IERC20Metadata token = IERC20Metadata(vaultTokens_[i]); _pullExistentials.push(10**(token.decimals() / 2)); } emit Initialized(tx.origin, msg.sender, vaultTokens_, nft_); } // -------------------------- EVENTS -------------------------- /// @notice Emitted when Vault is intialized /// @param origin Origin of the transaction (tx.origin) /// @param sender Sender of the call (msg.sender) /// @param vaultTokens_ ERC20 tokens under the vault management /// @param nft_ VaultRegistry NFT assigned to the vault event Initialized(address indexed origin, address indexed sender, address[] vaultTokens_, uint256 nft_); }
// SPDX-License-Identifier: BSL-1.1 pragma solidity 0.8.9; import "@openzeppelin/contracts/proxy/Clones.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; import "../interfaces/IProtocolGovernance.sol"; import "../interfaces/vaults/IVaultGovernance.sol"; import "../libraries/ExceptionsLibrary.sol"; import "../libraries/PermissionIdsLibrary.sol"; /// @notice Internal contract for managing different params. /// @dev The contract should be overriden by the concrete VaultGovernance, /// define different params structs and use abi.decode / abi.encode to serialize /// to bytes in this contract. It also should emit events on params change. abstract contract VaultGovernance is IVaultGovernance, ERC165 { InternalParams internal _internalParams; InternalParams private _stagedInternalParams; uint256 internal _internalParamsTimestamp; mapping(uint256 => bytes) internal _delayedStrategyParams; mapping(uint256 => bytes) internal _stagedDelayedStrategyParams; mapping(uint256 => uint256) internal _delayedStrategyParamsTimestamp; mapping(uint256 => bytes) internal _delayedProtocolPerVaultParams; mapping(uint256 => bytes) internal _stagedDelayedProtocolPerVaultParams; mapping(uint256 => uint256) internal _delayedProtocolPerVaultParamsTimestamp; bytes internal _delayedProtocolParams; bytes internal _stagedDelayedProtocolParams; uint256 internal _delayedProtocolParamsTimestamp; mapping(uint256 => bytes) internal _strategyParams; bytes internal _protocolParams; bytes internal _operatorParams; /// @notice Creates a new contract. /// @param internalParams_ Initial Internal Params constructor(InternalParams memory internalParams_) { require(address(internalParams_.protocolGovernance) != address(0), ExceptionsLibrary.ADDRESS_ZERO); require(address(internalParams_.registry) != address(0), ExceptionsLibrary.ADDRESS_ZERO); require(address(internalParams_.singleton) != address(0), ExceptionsLibrary.ADDRESS_ZERO); _internalParams = internalParams_; } // ------------------- EXTERNAL, VIEW ------------------- /// @inheritdoc IVaultGovernance function delayedStrategyParamsTimestamp(uint256 nft) external view returns (uint256) { return _delayedStrategyParamsTimestamp[nft]; } /// @inheritdoc IVaultGovernance function delayedProtocolPerVaultParamsTimestamp(uint256 nft) external view returns (uint256) { return _delayedProtocolPerVaultParamsTimestamp[nft]; } /// @inheritdoc IVaultGovernance function delayedProtocolParamsTimestamp() external view returns (uint256) { return _delayedProtocolParamsTimestamp; } /// @inheritdoc IVaultGovernance function internalParamsTimestamp() external view returns (uint256) { return _internalParamsTimestamp; } /// @inheritdoc IVaultGovernance function internalParams() external view returns (InternalParams memory) { return _internalParams; } /// @inheritdoc IVaultGovernance function stagedInternalParams() external view returns (InternalParams memory) { return _stagedInternalParams; } function supportsInterface(bytes4 interfaceID) public view virtual override(ERC165) returns (bool) { return super.supportsInterface(interfaceID) || interfaceID == type(IVaultGovernance).interfaceId; } // ------------------- EXTERNAL, MUTATING ------------------- /// @inheritdoc IVaultGovernance function stageInternalParams(InternalParams memory newParams) external { _requireProtocolAdmin(); require(address(newParams.protocolGovernance) != address(0), ExceptionsLibrary.ADDRESS_ZERO); require(address(newParams.registry) != address(0), ExceptionsLibrary.ADDRESS_ZERO); require(address(newParams.singleton) != address(0), ExceptionsLibrary.ADDRESS_ZERO); _stagedInternalParams = newParams; _internalParamsTimestamp = block.timestamp + _internalParams.protocolGovernance.governanceDelay(); emit StagedInternalParams(tx.origin, msg.sender, newParams, _internalParamsTimestamp); } /// @inheritdoc IVaultGovernance function commitInternalParams() external { _requireProtocolAdmin(); require(_internalParamsTimestamp != 0, ExceptionsLibrary.NULL); require(block.timestamp >= _internalParamsTimestamp, ExceptionsLibrary.TIMESTAMP); _internalParams = _stagedInternalParams; delete _internalParamsTimestamp; delete _stagedInternalParams; emit CommitedInternalParams(tx.origin, msg.sender, _internalParams); } // ------------------- INTERNAL, VIEW ------------------- function _requireAtLeastStrategy(uint256 nft) internal view { require( (_internalParams.protocolGovernance.isAdmin(msg.sender) || _internalParams.registry.getApproved(nft) == msg.sender || (_internalParams.registry.ownerOf(nft) == msg.sender)), ExceptionsLibrary.FORBIDDEN ); } function _requireProtocolAdmin() internal view { require(_internalParams.protocolGovernance.isAdmin(msg.sender), ExceptionsLibrary.FORBIDDEN); } function _requireAtLeastOperator() internal view { IProtocolGovernance governance = _internalParams.protocolGovernance; require(governance.isAdmin(msg.sender) || governance.isOperator(msg.sender), ExceptionsLibrary.FORBIDDEN); } // ------------------- INTERNAL, MUTATING ------------------- function _createVault(address owner) internal returns (address vault, uint256 nft) { IProtocolGovernance protocolGovernance = IProtocolGovernance(_internalParams.protocolGovernance); require( protocolGovernance.hasPermission(msg.sender, PermissionIdsLibrary.CREATE_VAULT), ExceptionsLibrary.FORBIDDEN ); IVaultRegistry vaultRegistry = _internalParams.registry; nft = vaultRegistry.vaultsCount() + 1; vault = Clones.cloneDeterministic(address(_internalParams.singleton), bytes32(nft)); vaultRegistry.registerVault(address(vault), owner); } /// @notice Set Delayed Strategy Params /// @param nft Nft of the vault /// @param params New params function _stageDelayedStrategyParams(uint256 nft, bytes memory params) internal { _requireAtLeastStrategy(nft); _stagedDelayedStrategyParams[nft] = params; uint256 delayFactor = _delayedStrategyParams[nft].length == 0 ? 0 : 1; _delayedStrategyParamsTimestamp[nft] = block.timestamp + _internalParams.protocolGovernance.governanceDelay() * delayFactor; } /// @notice Commit Delayed Strategy Params function _commitDelayedStrategyParams(uint256 nft) internal { _requireAtLeastStrategy(nft); uint256 thisDelayedStrategyParamsTimestamp = _delayedStrategyParamsTimestamp[nft]; require(thisDelayedStrategyParamsTimestamp != 0, ExceptionsLibrary.NULL); require(block.timestamp >= thisDelayedStrategyParamsTimestamp, ExceptionsLibrary.TIMESTAMP); _delayedStrategyParams[nft] = _stagedDelayedStrategyParams[nft]; delete _stagedDelayedStrategyParams[nft]; delete _delayedStrategyParamsTimestamp[nft]; } /// @notice Set Delayed Protocol Per Vault Params /// @param nft Nft of the vault /// @param params New params function _stageDelayedProtocolPerVaultParams(uint256 nft, bytes memory params) internal { _requireProtocolAdmin(); _stagedDelayedProtocolPerVaultParams[nft] = params; uint256 delayFactor = _delayedProtocolPerVaultParams[nft].length == 0 ? 0 : 1; _delayedProtocolPerVaultParamsTimestamp[nft] = block.timestamp + _internalParams.protocolGovernance.governanceDelay() * delayFactor; } /// @notice Commit Delayed Protocol Per Vault Params function _commitDelayedProtocolPerVaultParams(uint256 nft) internal { _requireProtocolAdmin(); uint256 thisDelayedProtocolPerVaultParamsTimestamp = _delayedProtocolPerVaultParamsTimestamp[nft]; require(thisDelayedProtocolPerVaultParamsTimestamp != 0, ExceptionsLibrary.NULL); require(block.timestamp >= thisDelayedProtocolPerVaultParamsTimestamp, ExceptionsLibrary.TIMESTAMP); _delayedProtocolPerVaultParams[nft] = _stagedDelayedProtocolPerVaultParams[nft]; delete _stagedDelayedProtocolPerVaultParams[nft]; delete _delayedProtocolPerVaultParamsTimestamp[nft]; } /// @notice Set Delayed Protocol Params /// @param params New params function _stageDelayedProtocolParams(bytes memory params) internal { _requireProtocolAdmin(); uint256 delayFactor = _delayedProtocolParams.length == 0 ? 0 : 1; _stagedDelayedProtocolParams = params; _delayedProtocolParamsTimestamp = block.timestamp + _internalParams.protocolGovernance.governanceDelay() * delayFactor; } /// @notice Commit Delayed Protocol Params function _commitDelayedProtocolParams() internal { _requireProtocolAdmin(); require(_delayedProtocolParamsTimestamp != 0, ExceptionsLibrary.NULL); require(block.timestamp >= _delayedProtocolParamsTimestamp, ExceptionsLibrary.TIMESTAMP); _delayedProtocolParams = _stagedDelayedProtocolParams; delete _stagedDelayedProtocolParams; delete _delayedProtocolParamsTimestamp; } /// @notice Set immediate strategy params /// @dev Should require nft > 0 /// @param nft Nft of the vault /// @param params New params function _setStrategyParams(uint256 nft, bytes memory params) internal { _requireAtLeastStrategy(nft); _strategyParams[nft] = params; } /// @notice Set immediate operator params /// @param params New params function _setOperatorParams(bytes memory params) internal { _requireAtLeastOperator(); _operatorParams = params; } /// @notice Set immediate protocol params /// @param params New params function _setProtocolParams(bytes memory params) internal { _requireProtocolAdmin(); _protocolParams = params; } // -------------------------- EVENTS -------------------------- /// @notice Emitted when InternalParams are staged for commit /// @param origin Origin of the transaction (tx.origin) /// @param sender Sender of the call (msg.sender) /// @param params New params that were staged for commit /// @param when When the params could be committed event StagedInternalParams(address indexed origin, address indexed sender, InternalParams params, uint256 when); /// @notice Emitted when InternalParams are staged for commit /// @param origin Origin of the transaction (tx.origin) /// @param sender Sender of the call (msg.sender) /// @param params New params that were staged for commit event CommitedInternalParams(address indexed origin, address indexed sender, InternalParams params); /// @notice Emitted when New Vault is deployed /// @param origin Origin of the transaction (tx.origin) /// @param sender Sender of the call (msg.sender) /// @param vaultTokens Vault tokens for this vault /// @param options Options for deploy. The details of the options structure are specified in subcontracts /// @param owner Owner of the VaultRegistry NFT for this vault /// @param vaultAddress Address of the new Vault /// @param vaultNft VaultRegistry NFT for the new Vault event DeployedVault( address indexed origin, address indexed sender, address[] vaultTokens, bytes options, address owner, address vaultAddress, uint256 vaultNft ); }
{ "evmVersion": "istanbul", "libraries": {}, "metadata": { "bytecodeHash": "ipfs", "useLiteralContent": true }, "optimizer": { "enabled": true, "runs": 200 }, "remappings": [], "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address[]","name":"tokens","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"actualTokenAmounts","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"lpTokenMinted","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"reason","type":"string"}],"name":"DepositCallbackLog","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"origin","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address[]","name":"vaultTokens_","type":"address[]"},{"indexed":false,"internalType":"uint256","name":"nft_","type":"uint256"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"treasury","type":"address"},{"indexed":false,"internalType":"uint256","name":"feeRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ManagementFeesCharged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"treasury","type":"address"},{"indexed":false,"internalType":"uint256","name":"feeRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PerformanceFeesCharged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"treasury","type":"address"},{"indexed":false,"internalType":"uint256","name":"feeRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ProtocolFeesCharged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address[]","name":"tokens","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"actualTokenAmounts","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"lpTokenBurned","type":"uint256"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"reason","type":"string"}],"name":"WithdrawCallbackLog","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"depositors","type":"address[]"}],"name":"addDepositorsToAllowlist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenAmounts","type":"uint256[]"},{"internalType":"uint256","name":"minLpTokens","type":"uint256"},{"internalType":"bytes","name":"vaultOptions","type":"bytes"}],"name":"deposit","outputs":[{"internalType":"uint256[]","name":"actualTokenAmounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositorsAllowlist","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"nft_","type":"uint256"}],"name":"hasSubvault","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"helper","outputs":[{"internalType":"contract IERC20RootVaultHelper","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"nft_","type":"uint256"},{"internalType":"address[]","name":"vaultTokens_","type":"address[]"},{"internalType":"address","name":"strategy_","type":"address"},{"internalType":"uint256[]","name":"subvaultNfts_","type":"uint256[]"},{"internalType":"contract IERC20RootVaultHelper","name":"helper_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isVaultToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastFeeCharge","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpPriceHighWaterMarkD18","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pullExistentials","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"depositors","type":"address[]"}],"name":"removeDepositorsFromAllowlist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"subvaultAt","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"subvaultNfts","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"nft_","type":"uint256"}],"name":"subvaultOneBasedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"totalWithdrawnAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWithdrawnAmountsTimestamp","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tvl","outputs":[{"internalType":"uint256[]","name":"minTokenAmounts","type":"uint256[]"},{"internalType":"uint256[]","name":"maxTokenAmounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vaultGovernance","outputs":[{"internalType":"contract IVaultGovernance","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vaultTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"lpTokenAmount","type":"uint256"},{"internalType":"uint256[]","name":"minTokenAmounts","type":"uint256[]"},{"internalType":"bytes[]","name":"vaultsOptions","type":"bytes[]"}],"name":"withdraw","outputs":[{"internalType":"uint256[]","name":"actualTokenAmounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"}]
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
[ 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.