Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
Latest 15 from a total of 15 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Rebalance | 18547255 | 232 days ago | IN | 0 ETH | 0.05919994 | ||||
Rebalance | 18475524 | 242 days ago | IN | 0 ETH | 0.03832064 | ||||
Rebalance | 18391590 | 254 days ago | IN | 0 ETH | 0.04974092 | ||||
Rebalance | 18319814 | 264 days ago | IN | 0 ETH | 0.01479524 | ||||
Rebalance | 18248279 | 274 days ago | IN | 0 ETH | 0.01706507 | ||||
Rebalance | 18176559 | 284 days ago | IN | 0 ETH | 0.03968178 | ||||
Rebalance | 18105135 | 294 days ago | IN | 0 ETH | 0.03701782 | ||||
Rebalance | 18081400 | 298 days ago | IN | 0 ETH | 0.04135609 | ||||
Rebalance | 18073600 | 299 days ago | IN | 0 ETH | 0.06457578 | ||||
Approve Token | 18073592 | 299 days ago | IN | 0 ETH | 0.00581013 | ||||
Approve Token | 18073590 | 299 days ago | IN | 0 ETH | 0.00247087 | ||||
Rebalance | 18033417 | 304 days ago | IN | 0 ETH | 0.05874356 | ||||
Rebalance | 18029101 | 305 days ago | IN | 0 ETH | 0.05467891 | ||||
Approve Token | 18024700 | 306 days ago | IN | 0 ETH | 0.00429677 | ||||
0x61010060 | 18024698 | 306 days ago | IN | Contract Creation | 0 ETH | 0.0920964 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0x662E10C8...86730dE04 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
AaveV3SommelierXy
Compiler Version
v0.8.9+commit.e5eed63a
Optimization Enabled:
Yes with 500 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol"; import "./AaveV3Xy.sol"; import "../../sommelier/SommelierBase.sol"; import "../../../interfaces/sommelier/ISommelier.sol"; /// @title Deposit Collateral in Aave and earn yield by depositing borrowed token in a Sommelier Vault. contract AaveV3SommelierXy is AaveV3Xy, SommelierBase { using SafeERC20 for IERC20; constructor( address _pool, address _swapper, address _receiptToken, address _borrowToken, address _aaveAddressProvider, address _cellar, string memory _name ) AaveV3Xy(_pool, _swapper, _receiptToken, _borrowToken, _aaveAddressProvider, _name) SommelierBase(_cellar) { require(ICellar(_cellar).asset() == borrowToken, "invalid-sommelier-vault"); } /// @dev After borrowing Y, deposit to Sommelier vault function _afterBorrowY(uint256 _amount) internal virtual override { _depositInSommelier(_amount); } /// @notice Approve all required tokens function _approveToken(uint256 _amount) internal virtual override { super._approveToken(_amount); IERC20(borrowToken).safeApprove(address(cellar), _amount); } /// @dev Before repaying Y, withdraw it from Sommelier vault function _beforeRepayY(uint256 _amount) internal virtual override { _withdrawFromSommelier(_amount); } /// @notice Borrowed Y balance deposited in Sommelier vault function _getInvestedBorrowBalance() internal view virtual override returns (uint256) { return _getAssetsInSommelier(); } /// @dev Swap excess borrow for more collateral when underlying Sommelier vault is making profits function _rebalanceBorrow(uint256 _excessBorrow) internal virtual override { if (_excessBorrow > 0) { _withdrawFromSommelier(_excessBorrow); uint256 _borrowedHere = IERC20(borrowToken).balanceOf(address(this)); if (_borrowedHere > 0) { _safeSwapExactInput(borrowToken, address(wrappedCollateral), _borrowedHere); } } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface IStrategy { function rebalance() external returns (uint256 _profit, uint256 _loss, uint256 _payback); function sweep(address _fromToken) external; function withdraw(uint256 _amount) external; function feeCollector() external view returns (address); function isReservedToken(address _token) external view returns (bool); function keepers() external view returns (address[] memory); function migrate(address _newStrategy) external; function token() external view returns (address); function pool() external view returns (address); // solhint-disable-next-line func-name-mixedcase function VERSION() external view returns (string memory); function collateral() external view returns (address); }
// SPDX-License-Identifier: MIT 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 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 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' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) + 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 // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } }
// SPDX-License-Identifier: MIT 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; /// @title Errors library library Errors { string public constant INVALID_COLLATERAL_AMOUNT = "1"; // Collateral must be greater than 0 or > defined limit string public constant INVALID_SHARE_AMOUNT = "2"; // Share must be greater than 0 string public constant INVALID_INPUT_LENGTH = "3"; // Input array length must be greater than 0 string public constant INPUT_LENGTH_MISMATCH = "4"; // Input array length mismatch with another array length string public constant NOT_WHITELISTED_ADDRESS = "5"; // Caller is not whitelisted to withdraw without fee string public constant MULTI_TRANSFER_FAILED = "6"; // Multi transfer of tokens has failed string public constant FEE_COLLECTOR_NOT_SET = "7"; // Fee Collector is not set string public constant NOT_ALLOWED_TO_SWEEP = "8"; // Token is not allowed to sweep string public constant INSUFFICIENT_BALANCE = "9"; // Insufficient balance to performs operations to follow string public constant INPUT_ADDRESS_IS_ZERO = "10"; // Input address is zero string public constant FEE_LIMIT_REACHED = "11"; // Fee must be less than MAX_BPS string public constant ALREADY_INITIALIZED = "12"; // Data structure, contract, or logic already initialized and can not be called again string public constant ADD_IN_LIST_FAILED = "13"; // Cannot add address in address list string public constant REMOVE_FROM_LIST_FAILED = "14"; // Cannot remove address from address list string public constant STRATEGY_IS_ACTIVE = "15"; // Strategy is already active, an inactive strategy is required string public constant STRATEGY_IS_NOT_ACTIVE = "16"; // Strategy is not active, an active strategy is required string public constant INVALID_STRATEGY = "17"; // Given strategy is not a strategy of this pool string public constant DEBT_RATIO_LIMIT_REACHED = "18"; // Debt ratio limit reached. It must be less than MAX_BPS string public constant TOTAL_DEBT_IS_NOT_ZERO = "19"; // Strategy total debt must be 0 string public constant LOSS_TOO_HIGH = "20"; // Strategy reported loss must be less than current debt string public constant INVALID_MAX_BORROW_LIMIT = "21"; // Max borrow limit is beyond range. string public constant MAX_LIMIT_LESS_THAN_MIN = "22"; // Max limit should be greater than min limit. string public constant INVALID_SLIPPAGE = "23"; // Slippage should be less than MAX_BPS string public constant WRONG_RECEIPT_TOKEN = "24"; // Wrong receipt token address string public constant AAVE_FLASH_LOAN_NOT_ACTIVE = "25"; // aave flash loan is not active string public constant DYDX_FLASH_LOAN_NOT_ACTIVE = "26"; // DYDX flash loan is not active string public constant INVALID_FLASH_LOAN = "27"; // invalid-flash-loan string public constant INVALID_INITIATOR = "28"; // "invalid-initiator" string public constant INCORRECT_WITHDRAW_AMOUNT = "29"; // withdrawn amount is not correct string public constant NO_MARKET_ID_FOUND = "30"; // dydx flash loan no marketId found for token string public constant SAME_AS_PREVIOUS = "31"; // Input should not be same as previous value. string public constant INVALID_INPUT = "32"; // Generic invalid input error code }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; /** * @notice Governable interface */ interface IGovernable { function governor() external view returns (address _governor); function transferGovernorship(address _proposedGovernor) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; /** * @notice Pausable interface */ interface IPausable { function paused() external view returns (bool); function stopEverything() external view returns (bool); function pause() external; function unpause() external; function shutdown() external; function open() external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface IPoolRewards { /// Emitted after reward added event RewardAdded(address indexed rewardToken, uint256 reward, uint256 rewardDuration); /// Emitted whenever any user claim rewards event RewardPaid(address indexed user, address indexed rewardToken, uint256 reward); /// Emitted after adding new rewards token into rewardTokens array event RewardTokenAdded(address indexed rewardToken, address[] existingRewardTokens); function claimReward(address) external; function notifyRewardAmount(address rewardToken_, uint256 _rewardAmount, uint256 _rewardDuration) external; function notifyRewardAmount( address[] memory rewardTokens_, uint256[] memory rewardAmounts_, uint256[] memory rewardDurations_ ) external; function updateReward(address) external; function claimable( address account_ ) external view returns (address[] memory _rewardTokens, uint256[] memory _claimableAmounts); function lastTimeRewardApplicable(address rewardToken_) external view returns (uint256); function rewardForDuration() external view returns (address[] memory _rewardTokens, uint256[] memory _rewardForDuration); function rewardPerToken() external view returns (address[] memory _rewardTokens, uint256[] memory _rewardPerTokenRate); function getRewardTokens() external view returns (address[] memory); function isRewardToken(address) external view returns (bool); function addRewardToken(address newRewardToken_) external; function periodFinish(address) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../../dependencies/openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "./IGovernable.sol"; import "./IPausable.sol"; interface IVesperPool is IGovernable, IPausable, IERC20Metadata { function calculateUniversalFee(uint256 profit_) external view returns (uint256 _fee); function deposit(uint256 collateralAmount_) external; function excessDebt(address strategy_) external view returns (uint256); function poolAccountant() external view returns (address); function poolRewards() external view returns (address); function reportEarning(uint256 profit_, uint256 loss_, uint256 payback_) external; function reportLoss(uint256 loss_) external; function sweepERC20(address fromToken_) external; function withdraw(uint256 share_) external; function keepers() external view returns (address[] memory); function isKeeper(address address_) external view returns (bool); function maintainers() external view returns (address[] memory); function isMaintainer(address address_) external view returns (bool); function pricePerShare() external view returns (uint256); function strategy( address strategy_ ) external view returns ( bool _active, uint256 _interestFee, // Obsolete uint256 _debtRate, // Obsolete uint256 _lastRebalance, uint256 _totalDebt, uint256 _totalLoss, uint256 _totalProfit, uint256 _debtRatio, uint256 _externalDepositFee ); function token() external view returns (IERC20); function tokensHere() external view returns (uint256); function totalDebtOf(address strategy_) external view returns (uint256); function totalValue() external view returns (uint256); function totalDebt() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol"; interface PoolAddressesProviderV3 { function getPool() external view returns (AaveLendingPool); function getPoolDataProvider() external view returns (AaveProtocolDataProvider); } // @dev Interface support both Aave v2 and v3 methods interface PoolAddressesProvider { function getPool() external view returns (address); // Aave v2 method. function getLendingPool() external view returns (address); function getPoolDataProvider() external view returns (address); function getAddress(bytes32 id) external view returns (address); function getPriceOracle() external view returns (address); } interface AaveOracle { function getAssetPrice(address _asset) external view returns (uint256); } interface AToken is IERC20 { /** * @dev Returns the address of the incentives controller contract **/ function getIncentivesController() external view returns (address); function mint(address user, uint256 amount, uint256 index) external returns (bool); function burn(address user, address receiverOfUnderlying, uint256 amount, uint256 index) external; //solhint-disable func-name-mixedcase function UNDERLYING_ASSET_ADDRESS() external view returns (address); } interface AaveIncentivesController { function getRewardsBalance(address[] calldata assets, address user) external view returns (uint256); function claimRewards(address[] calldata assets, uint256 amount, address to) external returns (uint256); function claimAllRewards( address[] calldata assets, address to ) external returns (address[] memory rewardsList, uint256[] memory claimedAmounts); function getRewardsList() external view returns (address[] memory); } interface AaveLendingPool { function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external; function withdraw(address asset, uint256 amount, address to) external returns (uint256); function flashLoan( address receiverAddress, address[] calldata assets, uint256[] calldata amounts, uint256[] calldata interestRateModes, address onBehalfOf, bytes calldata params, uint16 referralCode ) external; function borrow( address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf ) external; function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf) external; function getUserAccountData( address _user ) external view returns ( uint256 totalCollateralETH, uint256 totalDebtETH, uint256 availableBorrowsETH, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor ); } interface AaveProtocolDataProvider { function getReserveTokensAddresses( address asset ) external view returns (address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress); function getReserveData( address asset ) external view returns ( uint256 availableLiquidity, uint256 totalStableDebt, uint256 totalVariableDebt, uint256 liquidityRate, uint256 variableBorrowRate, uint256 stableBorrowRate, uint256 averageStableBorrowRate, uint256 liquidityIndex, uint256 variableBorrowIndex, uint40 lastUpdateTimestamp ); function getReserveConfigurationData( address asset ) external view returns ( uint256 decimals, uint256 ltv, uint256 liquidationThreshold, uint256 liquidationBonus, uint256 reserveFactor, bool usageAsCollateralEnabled, bool borrowingEnabled, bool stableBorrowRateEnabled, bool isActive, bool isFrozen ); } //solhint-disable func-name-mixedcase interface StakedAave is IERC20 { function claimRewards(address to, uint256 amount) external; function cooldown() external; function stake(address onBehalfOf, uint256 amount) external; function redeem(address to, uint256 amount) external; function getTotalRewardsBalance(address staker) external view returns (uint256); function stakersCooldowns(address staker) external view returns (uint256); function COOLDOWN_SECONDS() external view returns (uint256); function UNSTAKE_WINDOW() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol"; interface ICellar is IERC20 { function asset() external view returns (address); /** * @notice The amount of assets that the cellar would exchange for the amount of shares provided. * @param shares amount of shares to convert * @return assets the shares can be exchanged for */ function convertToAssets(uint256 shares) external view returns (uint256); /** * @notice After deposits users must wait `shareLockPeriod` time before being able to transfer or withdraw their shares. */ function shareLockPeriod() external view returns (uint256); /** * @notice The total amount of withdrawable assets in the cellar. * @dev Run a re-entrancy check because totalAssetsWithdrawable can be wrong if re-entering from deposit/withdraws. */ function totalAssetsWithdrawable() external view returns (uint256 assets); /** * @notice mapping that stores every users last time stamp they minted shares. */ function userShareLockStartTime(address user) external view returns (uint256 lockTime); /** * @notice Deposits assets into the cellar, and returns shares to receiver. * @param assets amount of assets deposited by user. * @param receiver address to receive the shares. * @return shares amount of shares given for deposit. */ function deposit(uint256 assets, address receiver) external returns (uint256 shares); /** * @notice Withdraw assets from the cellar by redeeming shares. * @dev Unlike conventional ERC4626 contracts, this may not always return one asset to the receiver. * Since there are no swaps involved in this function, the receiver may receive multiple * assets. The value of all the assets returned will be equal to the amount defined by * `assets` denominated in the `asset` of the cellar (eg. if `asset` is USDC and `assets` * is 1000, then the receiver will receive $1000 worth of assets in either one or many * tokens). * @param assets equivalent value of the assets withdrawn, denominated in the cellar's asset * @param receiver address that will receive withdrawn assets * @param owner address that owns the shares being redeemed * @return shares amount of shares redeemed */ function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; /** * @notice Routed Swapper interface * @dev This contract doesn't support native coins (e.g. ETH, AVAX, MATIC, etc) use wrapper tokens instead */ interface IRoutedSwapper { /** * @notice The list of supported DEXes * @dev This function is gas intensive */ function getAllExchanges() external view returns (address[] memory); /** * @notice Get *spot* quote * It will return the swap amount based on the current reserves of the best pair/path found (i.e. spot price). * @dev It shouldn't be used as oracle!!! */ function getAmountIn(address tokenIn_, address tokenOut_, uint256 amountOut_) external returns (uint256 _amountIn); /** * @notice Get *spot* quote * It will return the swap amount based on the current reserves of the best pair/path found (i.e. spot price). * @dev It shouldn't be used as oracle!!! */ function getAmountOut(address tokenIn_, address tokenOut_, uint256 amountIn_) external returns (uint256 _amountOut); /** * @notice Perform an exact input swap - will revert if there is no default routing */ function swapExactInput( address tokenIn_, address tokenOut_, uint256 amountIn_, uint256 amountOutMin_, address _receiver ) external returns (uint256 _amountOut); /** * @notice Perform an exact output swap - will revert if there is no default routing */ function swapExactOutput( address tokenIn_, address tokenOut_, uint256 amountOut_, uint256 amountInMax_, address receiver_ ) external returns (uint256 _amountIn); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "../../../interfaces/aave/IAave.sol"; /// @title This contract provide core operations for Aave v3 library AaveV3Incentive { /** * @notice Claim rewards from Aave incentive controller */ function _claimRewards( address _aToken ) internal returns (address[] memory rewardsList, uint256[] memory claimedAmounts) { // Some aTokens may have no incentive controller method/variable. Better use try catch try AToken(_aToken).getIncentivesController() returns (address _aaveIncentivesController) { address[] memory assets = new address[](1); assets[0] = address(_aToken); return AaveIncentivesController(_aaveIncentivesController).claimAllRewards(assets, address(this)); //solhint-disable no-empty-blocks } catch {} } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "vesper-pools/contracts/interfaces/vesper/IPoolRewards.sol"; import "vesper-pools/contracts/Errors.sol"; import "../../../interfaces/aave/IAave.sol"; import "./AaveV3Incentive.sol"; import "../../Strategy.sol"; // solhint-disable no-empty-blocks /// @title Deposit Collateral in Aave and earn interest by depositing borrowed token in a Vesper Pool. contract AaveV3Xy is Strategy { using SafeERC20 for IERC20; // solhint-disable-next-line var-name-mixedcase string public NAME; string public constant VERSION = "5.1.0"; uint256 internal constant MAX_BPS = 10_000; //100% uint256 public minBorrowLimit = 7_000; // 70% of actual collateral factor of protocol uint256 public maxBorrowLimit = 8_500; // 85% of actual collateral factor of protocol PoolAddressesProvider public immutable aaveAddressProvider; address public borrowToken; AToken public vdToken; // Variable Debt Token address internal aBorrowToken; IERC20 internal wrappedCollateral; event UpdatedBorrowLimit( uint256 previousMinBorrowLimit, uint256 newMinBorrowLimit, uint256 previousMaxBorrowLimit, uint256 newMaxBorrowLimit ); constructor( address _pool, address _swapper, address _receiptToken, address _borrowToken, address _aaveAddressProvider, string memory _name ) Strategy(_pool, _swapper, _receiptToken) { NAME = _name; require(_aaveAddressProvider != address(0), "addressProvider-is-zero"); wrappedCollateral = _getWrappedToken(collateralToken); require( AToken(_receiptToken).UNDERLYING_ASSET_ADDRESS() == address(wrappedCollateral), "invalid-receipt-token" ); (address _aBorrowToken, , address _vdToken) = AaveProtocolDataProvider( PoolAddressesProvider(_aaveAddressProvider).getPoolDataProvider() ).getReserveTokensAddresses(_borrowToken); vdToken = AToken(_vdToken); borrowToken = _borrowToken; aBorrowToken = _aBorrowToken; aaveAddressProvider = PoolAddressesProvider(_aaveAddressProvider); } function isReservedToken(address _token) public view virtual override returns (bool) { return _token == address(collateralToken) || _token == receiptToken || address(vdToken) == _token || borrowToken == _token; } /// @notice Returns total collateral locked in the strategy function tvl() external view virtual override returns (uint256) { // receiptToken is aToken. aToken is 1:1 of collateral token return IERC20(receiptToken).balanceOf(address(this)) + collateralToken.balanceOf(address(this)); } /// @notice After borrowing Y Hook function _afterBorrowY(uint256 _amount) internal virtual {} /// @notice Approve all required tokens function _approveToken(uint256 _amount) internal virtual override { super._approveToken(_amount); address _swapper = address(swapper); wrappedCollateral.safeApprove(aaveAddressProvider.getPool(), _amount); wrappedCollateral.safeApprove(_swapper, _amount); IERC20(borrowToken).safeApprove(aaveAddressProvider.getPool(), _amount); IERC20(borrowToken).safeApprove(_swapper, _amount); try AToken(receiptToken).getIncentivesController() returns (address _aaveIncentivesController) { address[] memory _rewardTokens = AaveIncentivesController(_aaveIncentivesController).getRewardsList(); for (uint256 i; i < _rewardTokens.length; ++i) { if (_rewardTokens[i] != address(collateralToken) && _rewardTokens[i] != borrowToken) { IERC20(_rewardTokens[i]).safeApprove(_swapper, _amount); } } //solhint-disable no-empty-blocks } catch {} } /** * @notice Claim rewardToken and transfer to new strategy * @param _newStrategy Address of new strategy. */ function _beforeMigration(address _newStrategy) internal virtual override { require(IStrategy(_newStrategy).token() == receiptToken, "wrong-receipt-token"); _repayY(vdToken.balanceOf(address(this)), AaveLendingPool(aaveAddressProvider.getPool())); } /// @notice Before repaying Y Hook function _beforeRepayY(uint256 _amount) internal virtual {} /** * @notice Calculate borrow and repay amount based on current collateral and new deposit/withdraw amount. * @param _depositAmount deposit amount * @param _withdrawAmount withdraw amount * @return _borrowAmount borrow more amount * @return _repayAmount repay amount to keep ltv within limit */ function _calculateBorrowPosition( uint256 _depositAmount, uint256 _withdrawAmount, uint256 _borrowed, uint256 _supplied ) internal view returns (uint256 _borrowAmount, uint256 _repayAmount) { require(_depositAmount == 0 || _withdrawAmount == 0, "all-input-gt-zero"); // If maximum borrow limit set to 0 then repay borrow if (maxBorrowLimit == 0) { return (0, _borrowed); } // In case of withdraw, _amount can be greater than _supply uint256 _hypotheticalCollateral = _depositAmount > 0 ? _supplied + _depositAmount : _supplied > _withdrawAmount ? _supplied - _withdrawAmount : 0; if (_hypotheticalCollateral == 0) { return (0, _borrowed); } AaveOracle _aaveOracle = AaveOracle(aaveAddressProvider.getPriceOracle()); uint256 _borrowTokenPrice = _aaveOracle.getAssetPrice(borrowToken); uint256 _collateralTokenPrice = _aaveOracle.getAssetPrice(address(wrappedCollateral)); if (_borrowTokenPrice == 0 || _collateralTokenPrice == 0) { // Oracle problem. Lets payback all return (0, _borrowed); } // _collateralFactor in 4 decimal. 10_000 = 100% (, uint256 _collateralFactor, , , , , , , , ) = AaveProtocolDataProvider( aaveAddressProvider.getPoolDataProvider() ).getReserveConfigurationData(address(wrappedCollateral)); // Collateral in base currency based on oracle price and cf; uint256 _actualCollateralForBorrow = (_hypotheticalCollateral * _collateralFactor * _collateralTokenPrice) / (MAX_BPS * (10 ** IERC20Metadata(address(wrappedCollateral)).decimals())); // Calculate max borrow possible in borrow token number uint256 _maxBorrowPossible = (_actualCollateralForBorrow * (10 ** IERC20Metadata(address(borrowToken)).decimals())) / _borrowTokenPrice; if (_maxBorrowPossible == 0) { return (0, _borrowed); } // Safe buffer to avoid liquidation due to price variations. uint256 _borrowUpperBound = (_maxBorrowPossible * maxBorrowLimit) / MAX_BPS; // Borrow up to _borrowLowerBound and keep buffer of _borrowUpperBound - _borrowLowerBound for price variation uint256 _borrowLowerBound = (_maxBorrowPossible * minBorrowLimit) / MAX_BPS; // If current borrow is greater than max borrow, then repay to achieve safe position. if (_borrowed > _borrowUpperBound) { // If borrow > upperBound then it is greater than lowerBound too. _repayAmount = _borrowed - _borrowLowerBound; } else if (_borrowLowerBound > _borrowed) { _borrowAmount = _borrowLowerBound - _borrowed; uint256 _availableLiquidity = IERC20(borrowToken).balanceOf(aBorrowToken); if (_borrowAmount > _availableLiquidity) { _borrowAmount = _availableLiquidity; } } } function _calculateUnwrapped(uint256 wrappedAmount_) internal view virtual returns (uint256) { return wrappedAmount_; } function _calculateWrapped(uint256 unwrappedAmount_) internal view virtual returns (uint256) { return unwrappedAmount_; } /// @dev Claim all rewards and convert to collateral. /// Overriding _claimAndSwapRewards will help child contract otherwise override _claimReward. function _claimAndSwapRewards() internal virtual override { (address[] memory _tokens, uint256[] memory _amounts) = AaveV3Incentive._claimRewards(receiptToken); uint256 _length = _tokens.length; for (uint256 i; i < _length; ++i) { if (_amounts[i] > 0 && _tokens[i] != address(wrappedCollateral)) { _safeSwapExactInput(_tokens[i], address(wrappedCollateral), _amounts[i]); } } } function _convertToWrapped(uint256 amount_) internal view virtual returns (uint256) { return amount_; } function _depositToAave(uint256 _amount, AaveLendingPool _aaveLendingPool) internal virtual { uint256 _wrappedAmount = _wrap(_amount); if (_wrappedAmount > 0) { try _aaveLendingPool.supply(address(wrappedCollateral), _wrappedAmount, address(this), 0) {} catch Error( string memory _reason ) { // Aave uses liquidityIndex and some other indexes as needed to normalize input. // If normalized input equals to 0 then error will be thrown with '56' error code. // CT_INVALID_MINT_AMOUNT = '56'; //invalid amount to mint // Hence discard error where error code is '56' require(bytes32(bytes(_reason)) == "56", "deposit failed"); } } } function _getCollateralHere() internal virtual returns (uint256) { return collateralToken.balanceOf(address(this)); } /// @notice Borrowed Y balance deposited here or elsewhere hook function _getInvestedBorrowBalance() internal view virtual returns (uint256) { return IERC20(borrowToken).balanceOf(address(this)); } function _getWrappedToken(IERC20 unwrappedToken_) internal pure virtual returns (IERC20) { return unwrappedToken_; } /** * @dev Generate report for pools accounting and also send profit and any payback to pool. */ function _rebalance() internal override returns (uint256 _profit, uint256 _loss, uint256 _payback) { // NOTE:: Pool has unwrapped as collateral and any state is also unwrapped amount uint256 _excessDebt = IVesperPool(pool).excessDebt(address(this)); uint256 _borrowed = vdToken.balanceOf(address(this)); uint256 _investedBorrowBalance = _getInvestedBorrowBalance(); AaveLendingPool _aaveLendingPool = AaveLendingPool(aaveAddressProvider.getPool()); // _borrow increases every block. Convert collateral to borrowToken. if (_borrowed > _investedBorrowBalance) { _swapToBorrowToken(_borrowed - _investedBorrowBalance, _aaveLendingPool); } else { // When _investedBorrowBalance exceeds _borrow balance from Aave // Customize this hook to handle the excess borrowToken for profit _rebalanceBorrow(_investedBorrowBalance - _borrowed); } uint256 _collateralHere = _getCollateralHere(); uint256 _supplied = _calculateUnwrapped(IERC20(receiptToken).balanceOf(address(this))); uint256 _totalCollateral = _supplied + _collateralHere; uint256 _totalDebt = IVesperPool(pool).totalDebtOf(address(this)); if (_totalCollateral > _totalDebt) { _profit = _totalCollateral - _totalDebt; } else { _loss = _totalDebt - _totalCollateral; } uint256 _profitAndExcessDebt = _profit + _excessDebt; if (_collateralHere < _profitAndExcessDebt) { uint256 _totalAmountToWithdraw = Math.min((_profitAndExcessDebt - _collateralHere), _supplied); if (_totalAmountToWithdraw > 0) { _withdrawHere(_totalAmountToWithdraw, _aaveLendingPool, _borrowed, _supplied); _collateralHere = collateralToken.balanceOf(address(this)); } } // Make sure _collateralHere >= _payback + profit. set actual payback first and then profit _payback = Math.min(_collateralHere, _excessDebt); _profit = _collateralHere > _payback ? Math.min((_collateralHere - _payback), _profit) : 0; IVesperPool(pool).reportEarning(_profit, _loss, _payback); // This is unwrapped balance if pool supports unwrap token eg stETH uint256 _newSupply = collateralToken.balanceOf(address(this)); if (_newSupply > 0) { _depositToAave(_newSupply, _aaveLendingPool); } // There are scenarios when we want to call _calculateBorrowPosition and act on it. // 1. Strategy got some collateral from pool which will allow strategy to borrow more. // 2. Collateral and/or borrow token price is changed which leads to repay or borrow. // 3. BorrowLimits are updated. // In some edge scenarios, below call is redundant but keeping it as is for simplicity. (uint256 _borrowAmount, uint256 _repayAmount) = _calculateBorrowPosition( 0, 0, vdToken.balanceOf(address(this)), IERC20(receiptToken).balanceOf(address(this)) ); if (_repayAmount > 0) { // Repay _borrowAmount to maintain safe position _repayY(_repayAmount, _aaveLendingPool); } else if (_borrowAmount > 0) { // 2 for variable rate borrow, 0 for referralCode _aaveLendingPool.borrow(borrowToken, _borrowAmount, 2, 0, address(this)); } uint256 _borrowTokenBalance = IERC20(borrowToken).balanceOf(address(this)); if (_borrowTokenBalance > 0) { _afterBorrowY(_borrowTokenBalance); } } /// @notice Swap excess borrow for more collateral hook function _rebalanceBorrow(uint256 _excessBorrow) internal virtual {} function _repayY(uint256 _amount, AaveLendingPool _aaveLendingPool) internal virtual { _beforeRepayY(_amount); _aaveLendingPool.repay(borrowToken, _amount, 2, address(this)); } /** * @dev Swap collateral to borrow token. * @param _shortOnBorrow Expected output of this swap */ function _swapToBorrowToken(uint256 _shortOnBorrow, AaveLendingPool _aaveLendingPool) internal { // Looking for _amountIn using fixed output amount uint256 _amountIn = swapper.getAmountIn(address(wrappedCollateral), borrowToken, _shortOnBorrow); if (_amountIn > 0) { // Not using unwrapped balance here as those can be used in rebalance reporting via getCollateralHere uint256 _collateralHere = wrappedCollateral.balanceOf(address(this)); if (_amountIn > _collateralHere) { // Withdraw some collateral from Aave so that we have enough collateral to get expected output uint256 _amount = _amountIn - _collateralHere; require( _aaveLendingPool.withdraw(address(wrappedCollateral), _amount, address(this)) == _amount, Errors.INCORRECT_WITHDRAW_AMOUNT ); } swapper.swapExactOutput(address(wrappedCollateral), borrowToken, _shortOnBorrow, _amountIn, address(this)); } } function _unwrap(uint256 wrappedAmount_) internal virtual returns (uint256) { return wrappedAmount_; } function _wrap(uint256 unwrappedAmount_) internal virtual returns (uint256) { return unwrappedAmount_; } /// @dev If pool supports unwrapped token(stETH) then input and output both are unwrapped token amount. function _withdrawHere(uint256 _requireAmount) internal override { _withdrawHere( _requireAmount, AaveLendingPool(aaveAddressProvider.getPool()), vdToken.balanceOf(address(this)), IERC20(receiptToken).balanceOf(address(this)) ); } /// @dev If pool supports unwrapped token(stETH) then _requireAmount and output both are unwrapped token amount. function _withdrawHere( uint256 _requireAmount, AaveLendingPool _aaveLendingPool, uint256 _borrowed, uint256 _supplied ) internal { uint256 _wrappedRequireAmount = _calculateWrapped(_requireAmount); (, uint256 _repayAmount) = _calculateBorrowPosition(0, _wrappedRequireAmount, _borrowed, _supplied); if (_repayAmount > 0) { _repayY(_repayAmount, _aaveLendingPool); } // withdraw asking more than available liquidity will fail. To do safe withdraw, check // _wrappedRequireAmount against available liquidity. uint256 _possibleWithdraw = Math.min( _wrappedRequireAmount, Math.min(IERC20(receiptToken).balanceOf(address(this)), wrappedCollateral.balanceOf(receiptToken)) ); require( _aaveLendingPool.withdraw(address(wrappedCollateral), _possibleWithdraw, address(this)) == _possibleWithdraw, Errors.INCORRECT_WITHDRAW_AMOUNT ); // Unwrap wrapped tokens _unwrap(wrappedCollateral.balanceOf(address(this))); } /************************************************************************************************ * Governor/admin/keeper function * ***********************************************************************************************/ /** * @notice Update upper and lower borrow limit. Usually maxBorrowLimit < 100% of actual collateral factor of protocol. * @dev It is possible to set _maxBorrowLimit and _minBorrowLimit as 0 to not borrow anything * @param _minBorrowLimit It is % of actual collateral factor of protocol * @param _maxBorrowLimit It is % of actual collateral factor of protocol */ function updateBorrowLimit(uint256 _minBorrowLimit, uint256 _maxBorrowLimit) external onlyGovernor { require(_maxBorrowLimit < MAX_BPS, "invalid-max-borrow-limit"); // set _maxBorrowLimit and _minBorrowLimit to disable borrow; require( (_maxBorrowLimit == 0 && _minBorrowLimit == 0) || _maxBorrowLimit > _minBorrowLimit, "max-should-be-higher-than-min" ); emit UpdatedBorrowLimit(minBorrowLimit, _minBorrowLimit, maxBorrowLimit, _maxBorrowLimit); minBorrowLimit = _minBorrowLimit; maxBorrowLimit = _maxBorrowLimit; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol"; import "../../interfaces/sommelier/ISommelier.sol"; /// @dev This strategy will deposit collateral token in Sommelier and earn yield. abstract contract SommelierBase { // Same as receiptToken but it's immutable and saves gas ICellar public immutable cellar; constructor(address cellar_) { cellar = ICellar(cellar_); } /** * @notice Time when withdraw and transfer will be unlocked. */ function unlockTime() public view returns (uint256) { return cellar.userShareLockStartTime(address(this)) + cellar.shareLockPeriod(); } function _depositInSommelier(uint256 amount_) internal returns (uint256 shares_) { shares_ = cellar.deposit(amount_, address(this)); } function _getAssetsInSommelier() internal view returns (uint256) { return cellar.convertToAssets(cellar.balanceOf(address(this))); } /** * @dev Withdraw from sommelier vault * @param requireAmount_ equivalent value of the assets withdrawn, denominated in the cellar's asset * @return shares_ amount of shares redeemed */ function _withdrawFromSommelier(uint256 requireAmount_) internal returns (uint256 shares_) { if (block.timestamp >= unlockTime()) { // withdraw asking more than available liquidity will fail. To do safe withdraw, check // requireAmount_ against available liquidity. uint256 _withdrawable = Math.min( requireAmount_, Math.min(_getAssetsInSommelier(), cellar.totalAssetsWithdrawable()) ); if (_withdrawable > 0) { shares_ = cellar.withdraw(_withdrawable, address(this), address(this)); } } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; import "vesper-pools/contracts/interfaces/vesper/IVesperPool.sol"; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol"; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol"; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol"; import "vesper-commons/contracts/interfaces/vesper/IStrategy.sol"; import "../interfaces/swapper/IRoutedSwapper.sol"; abstract contract Strategy is IStrategy, Context { using SafeERC20 for IERC20; using EnumerableSet for EnumerableSet.AddressSet; IERC20 public immutable collateralToken; address public receiptToken; address public immutable override pool; address public override feeCollector; IRoutedSwapper public swapper; address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; uint256 internal constant MAX_UINT_VALUE = type(uint256).max; EnumerableSet.AddressSet private _keepers; event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector); event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper); constructor(address _pool, address _swapper, address _receiptToken) { require(_pool != address(0), "pool-address-is-zero"); require(_swapper != address(0), "swapper-address-is-zero"); swapper = IRoutedSwapper(_swapper); pool = _pool; collateralToken = IVesperPool(_pool).token(); receiptToken = _receiptToken; require(_keepers.add(_msgSender()), "add-keeper-failed"); } modifier onlyGovernor() { require(_msgSender() == IVesperPool(pool).governor(), "caller-is-not-the-governor"); _; } modifier onlyKeeper() { require(_keepers.contains(_msgSender()), "caller-is-not-a-keeper"); _; } modifier onlyPool() { require(_msgSender() == pool, "caller-is-not-vesper-pool"); _; } /** * @notice Add given address in keepers list. * @param _keeperAddress keeper address to add. */ function addKeeper(address _keeperAddress) external onlyGovernor { require(_keepers.add(_keeperAddress), "add-keeper-failed"); } /// @dev Approve all required tokens function approveToken(uint256 _approvalAmount) external onlyKeeper { _approveToken(_approvalAmount); } /// @notice Claim rewardToken and convert rewardToken into collateral token. function claimAndSwapRewards(uint256 _minAmountOut) external onlyKeeper returns (uint256 _amountOut) { uint256 _collateralBefore = collateralToken.balanceOf(address(this)); _claimAndSwapRewards(); _amountOut = collateralToken.balanceOf(address(this)) - _collateralBefore; require(_amountOut >= _minAmountOut, "not-enough-amountOut"); } /// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep. function isReservedToken(address _token) public view virtual override returns (bool); /// @notice Return list of keepers function keepers() external view override returns (address[] memory) { return _keepers.values(); } /** * @notice Migrate all asset and vault ownership,if any, to new strategy * @dev _beforeMigration hook can be implemented in child strategy to do extra steps. * @param _newStrategy Address of new strategy */ function migrate(address _newStrategy) external virtual override onlyPool { require(_newStrategy != address(0), "new-strategy-address-is-zero"); require(IStrategy(_newStrategy).pool() == pool, "not-valid-new-strategy"); _beforeMigration(_newStrategy); IERC20(receiptToken).safeTransfer(_newStrategy, IERC20(receiptToken).balanceOf(address(this))); collateralToken.safeTransfer(_newStrategy, collateralToken.balanceOf(address(this))); } /** * @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy. * Calculate profit, loss and payback of this strategy and realize profit/loss and * withdraw fund for payback, if any, and submit this report to pool. * @return _profit Realized profit in collateral. * @return _loss Realized loss, if any, in collateral. * @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt. */ function rebalance() external onlyKeeper returns (uint256 _profit, uint256 _loss, uint256 _payback) { return _rebalance(); } /** * @notice Remove given address from keepers list. * @param _keeperAddress keeper address to remove. */ function removeKeeper(address _keeperAddress) external onlyGovernor { require(_keepers.remove(_keeperAddress), "remove-keeper-failed"); } /// @notice onlyKeeper:: Swap given token into collateral token. function swapToCollateral(IERC20 _tokenIn, uint256 _minAmountOut) external onlyKeeper returns (uint256 _amountOut) { require(address(_tokenIn) != address(collateralToken), "not-allowed-to-sweep-collateral"); require(!isReservedToken(address(_tokenIn)), "not-allowed-to-sweep"); uint256 _collateralBefore = collateralToken.balanceOf(address(this)); uint256 _amountIn = _tokenIn.balanceOf(address(this)); if (_amountIn > 0) { if (_amountIn > _tokenIn.allowance(address(this), address(swapper))) { _tokenIn.safeApprove(address(swapper), 0); _tokenIn.safeApprove(address(swapper), MAX_UINT_VALUE); } _swapExactInput(address(_tokenIn), address(collateralToken), _amountIn); } _amountOut = collateralToken.balanceOf(address(this)) - _collateralBefore; require(_amountOut >= _minAmountOut, "not-enough-amountOut"); } /** * @notice sweep given token to feeCollector of strategy * @param _fromToken token address to sweep */ function sweep(address _fromToken) external override onlyKeeper { require(feeCollector != address(0), "fee-collector-not-set"); require(_fromToken != address(collateralToken), "not-allowed-to-sweep-collateral"); require(!isReservedToken(_fromToken), "not-allowed-to-sweep"); if (_fromToken == ETH) { Address.sendValue(payable(feeCollector), address(this).balance); } else { uint256 _amount = IERC20(_fromToken).balanceOf(address(this)); IERC20(_fromToken).safeTransfer(feeCollector, _amount); } } /// @notice Returns address of token correspond to receipt token function token() external view override returns (address) { return receiptToken; } /// @notice Returns address of token correspond to collateral token function collateral() external view override returns (address) { return address(collateralToken); } /// @notice Returns total collateral locked in the strategy function tvl() external view virtual returns (uint256); /** * @notice Update fee collector * @param _feeCollector fee collector address */ function updateFeeCollector(address _feeCollector) external onlyGovernor { require(_feeCollector != address(0), "fee-collector-address-is-zero"); require(_feeCollector != feeCollector, "fee-collector-is-same"); emit UpdatedFeeCollector(feeCollector, _feeCollector); feeCollector = _feeCollector; } /** * @notice Update swapper * @param _swapper swapper address */ function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor { require(address(_swapper) != address(0), "swapper-address-is-zero"); require(_swapper != swapper, "swapper-is-same"); emit UpdatedSwapper(swapper, _swapper); swapper = _swapper; } /** * @notice Withdraw collateral token from end protocol. * @param _amount Amount of collateral token */ function withdraw(uint256 _amount) external override onlyPool { uint256 _collateralHere = collateralToken.balanceOf(address(this)); if (_collateralHere >= _amount) { collateralToken.safeTransfer(pool, _amount); } else { _withdrawHere(_amount - _collateralHere); // Do not assume _withdrawHere() will withdraw exact amount. Check balance again and transfer to pool _collateralHere = collateralToken.balanceOf(address(this)); collateralToken.safeTransfer(pool, Math.min(_amount, _collateralHere)); } } function _approveToken(uint256 _amount) internal virtual { collateralToken.safeApprove(pool, _amount); } /** * @dev some strategy may want to prepare before doing migration. * Example In Maker old strategy want to give vault ownership to new strategy * @param _newStrategy . */ function _beforeMigration(address _newStrategy) internal virtual; function _claimAndSwapRewards() internal virtual { (address _rewardToken, uint256 _rewardsAmount) = _claimRewards(); if (_rewardsAmount > 0) { _safeSwapExactInput(_rewardToken, address(collateralToken), _rewardsAmount); } } // solhint-disable-next-line no-empty-blocks function _claimRewards() internal virtual returns (address, uint256) {} function _rebalance() internal virtual returns (uint256 _profit, uint256 _loss, uint256 _payback); function _swapExactInput( address _tokenIn, address _tokenOut, uint256 _amountIn ) internal returns (uint256 _amountOut) { _amountOut = swapper.swapExactInput(_tokenIn, _tokenOut, _amountIn, 1, address(this)); } function _safeSwapExactInput(address _tokenIn, address _tokenOut, uint256 _amountIn) internal { try swapper.swapExactInput(_tokenIn, _tokenOut, _amountIn, 1, address(this)) {} catch {} //solhint-disable no-empty-blocks } // These methods must be implemented by the inheriting strategy function _withdrawHere(uint256 _amount) internal virtual; }
{ "optimizer": { "enabled": true, "runs": 500 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_pool","type":"address"},{"internalType":"address","name":"_swapper","type":"address"},{"internalType":"address","name":"_receiptToken","type":"address"},{"internalType":"address","name":"_borrowToken","type":"address"},{"internalType":"address","name":"_aaveAddressProvider","type":"address"},{"internalType":"address","name":"_cellar","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"previousMinBorrowLimit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMinBorrowLimit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"previousMaxBorrowLimit","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxBorrowLimit","type":"uint256"}],"name":"UpdatedBorrowLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousFeeCollector","type":"address"},{"indexed":true,"internalType":"address","name":"newFeeCollector","type":"address"}],"name":"UpdatedFeeCollector","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IRoutedSwapper","name":"oldSwapper","type":"address"},{"indexed":true,"internalType":"contract IRoutedSwapper","name":"newSwapper","type":"address"}],"name":"UpdatedSwapper","type":"event"},{"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"aaveAddressProvider","outputs":[{"internalType":"contract PoolAddressesProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_keeperAddress","type":"address"}],"name":"addKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_approvalAmount","type":"uint256"}],"name":"approveToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"borrowToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cellar","outputs":[{"internalType":"contract ICellar","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minAmountOut","type":"uint256"}],"name":"claimAndSwapRewards","outputs":[{"internalType":"uint256","name":"_amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"collateral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"collateralToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeCollector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"isReservedToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keepers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBorrowLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newStrategy","type":"address"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minBorrowLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebalance","outputs":[{"internalType":"uint256","name":"_profit","type":"uint256"},{"internalType":"uint256","name":"_loss","type":"uint256"},{"internalType":"uint256","name":"_payback","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"receiptToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_keeperAddress","type":"address"}],"name":"removeKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_tokenIn","type":"address"},{"internalType":"uint256","name":"_minAmountOut","type":"uint256"}],"name":"swapToCollateral","outputs":[{"internalType":"uint256","name":"_amountOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapper","outputs":[{"internalType":"contract IRoutedSwapper","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_fromToken","type":"address"}],"name":"sweep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tvl","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minBorrowLimit","type":"uint256"},{"internalType":"uint256","name":"_maxBorrowLimit","type":"uint256"}],"name":"updateBorrowLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeCollector","type":"address"}],"name":"updateFeeCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IRoutedSwapper","name":"_swapper","type":"address"}],"name":"updateSwapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vdToken","outputs":[{"internalType":"contract AToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $3,868 | 118.9585 | $460,131.35 |
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.