File size: 59,858 Bytes
f998fcd |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 |
{
"language": "Solidity",
"settings": {
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 100
},
"remappings": [],
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
},
"sources": {
"vesper-commons/contracts/interfaces/vesper/IStrategy.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\ninterface IStrategy {\n function rebalance()\n external\n returns (\n uint256 _profit,\n uint256 _loss,\n uint256 _payback\n );\n\n function sweepERC20(address _fromToken) external;\n\n function withdraw(uint256 _amount) external;\n\n function feeCollector() external view returns (address);\n\n function isReservedToken(address _token) external view returns (bool);\n\n function keepers() external view returns (address[] memory);\n\n function migrate(address _newStrategy) external;\n\n function token() external view returns (address);\n\n function pool() external view returns (address);\n\n // solhint-disable-next-line func-name-mixedcase\n function VERSION() external view returns (string memory);\n\n function collateral() external view returns (address);\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n using Address for address;\n\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n }\n\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n }\n\n /**\n * @dev Deprecated. This function has issues similar to the ones found in\n * {IERC20-approve}, and its usage is discouraged.\n *\n * Whenever possible, use {safeIncreaseAllowance} and\n * {safeDecreaseAllowance} instead.\n */\n function safeApprove(IERC20 token, address spender, uint256 value) internal {\n // safeApprove should only be called when setting an initial allowance,\n // or when resetting it to zero. To increase and decrease it, use\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n // solhint-disable-next-line max-line-length\n require((value == 0) || (token.allowance(address(this), spender) == 0),\n \"SafeERC20: approve from non-zero to non-zero allowance\"\n );\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n }\n\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n uint256 newAllowance = token.allowance(address(this), spender) + value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n unchecked {\n uint256 oldAllowance = token.allowance(address(this), spender);\n require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n uint256 newAllowance = oldAllowance - value;\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n }\n }\n\n /**\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n * on the return value: the return value is optional (but if data is returned, it must not be false).\n * @param token The token targeted by the call.\n * @param data The call data (encoded using abi.encode or one of its variants).\n */\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n // the target address contains contract code and also asserts for success in the low-level call.\n\n bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n if (returndata.length > 0) { // Return data is optional\n // solhint-disable-next-line max-line-length\n require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n }\n }\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n /**\n * @dev Returns true if `account` is a contract.\n *\n * [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n *\n * Among others, `isContract` will return false for the following\n * types of addresses:\n *\n * - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n */\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize, which returns 0 for contracts in\n // construction, since the code is only stored at the end of the\n // constructor execution.\n\n uint256 size;\n // solhint-disable-next-line no-inline-assembly\n assembly { size := extcodesize(account) }\n return size > 0;\n }\n\n /**\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n *\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n *\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n *\n * IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n */\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\n (bool success, ) = recipient.call{ value: amount }(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /**\n * @dev Performs a Solidity function call using a low level `call`. A\n * plain`call` is an unsafe replacement for a function call: use this\n * function instead.\n *\n * If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n *\n * Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n *\n * Requirements:\n *\n * - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n *\n * Requirements:\n *\n * - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n *\n * _Available since v3.1._\n */\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n *\n * _Available since v3.3._\n */\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.staticcall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n }\n\n /**\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a delegate call.\n *\n * _Available since v3.4._\n */\n function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\n require(isContract(target), \"Address: delegate call to non-contract\");\n\n // solhint-disable-next-line avoid-low-level-calls\n (bool success, bytes memory returndata) = target.delegatecall(data);\n return _verifyCallResult(success, returndata, errorMessage);\n }\n\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/*\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691\n return msg.data;\n }\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n /**\n * @dev Returns the largest of two numbers.\n */\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\n return a >= b ? a : b;\n }\n\n /**\n * @dev Returns the smallest of two numbers.\n */\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\n return a < b ? a : b;\n }\n\n /**\n * @dev Returns the average of two numbers. The result is rounded towards\n * zero.\n */\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\n // (a + b) / 2 can overflow, so we distribute\n return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);\n }\n}\n"
},
"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n * // Add the library methods\n * using EnumerableSet for EnumerableSet.AddressSet;\n *\n * // Declare a set state variable\n * EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n // To implement this library for multiple types with as little code\n // repetition as possible, we write it in terms of a generic Set type with\n // bytes32 values.\n // The Set implementation uses private functions, and user-facing\n // implementations (such as AddressSet) are just wrappers around the\n // underlying Set.\n // This means that we can only create new EnumerableSets for types that fit\n // in bytes32.\n\n struct Set {\n // Storage of set values\n bytes32[] _values;\n // Position of the value in the `values` array, plus 1 because index 0\n // means a value is not in the set.\n mapping(bytes32 => uint256) _indexes;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function _add(Set storage set, bytes32 value) private returns (bool) {\n if (!_contains(set, value)) {\n set._values.push(value);\n // The value is stored at length-1, but we add 1 to all indexes\n // and use 0 as a sentinel value\n set._indexes[value] = set._values.length;\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function _remove(Set storage set, bytes32 value) private returns (bool) {\n // We read and store the value's index to prevent multiple reads from the same storage slot\n uint256 valueIndex = set._indexes[value];\n\n if (valueIndex != 0) {\n // Equivalent to contains(set, value)\n // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n // the array, and then remove the last element (sometimes called as 'swap and pop').\n // This modifies the order of the array, as noted in {at}.\n\n uint256 toDeleteIndex = valueIndex - 1;\n uint256 lastIndex = set._values.length - 1;\n\n if (lastIndex != toDeleteIndex) {\n bytes32 lastvalue = set._values[lastIndex];\n\n // Move the last value to the index where the value to delete is\n set._values[toDeleteIndex] = lastvalue;\n // Update the index for the moved value\n set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n }\n\n // Delete the slot where the moved value was stored\n set._values.pop();\n\n // Delete the index for the deleted slot\n delete set._indexes[value];\n\n return true;\n } else {\n return false;\n }\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function _contains(Set storage set, bytes32 value) private view returns (bool) {\n return set._indexes[value] != 0;\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function _length(Set storage set) private view returns (uint256) {\n return set._values.length;\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function _at(Set storage set, uint256 index) private view returns (bytes32) {\n return set._values[index];\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function _values(Set storage set) private view returns (bytes32[] memory) {\n return set._values;\n }\n\n // Bytes32Set\n\n struct Bytes32Set {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _add(set._inner, value);\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n return _remove(set._inner, value);\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n return _contains(set._inner, value);\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(Bytes32Set storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n return _at(set._inner, index);\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\n return _values(set._inner);\n }\n\n // AddressSet\n\n struct AddressSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(AddressSet storage set, address value) internal returns (bool) {\n return _add(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(AddressSet storage set, address value) internal returns (bool) {\n return _remove(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(AddressSet storage set, address value) internal view returns (bool) {\n return _contains(set._inner, bytes32(uint256(uint160(value))));\n }\n\n /**\n * @dev Returns the number of values in the set. O(1).\n */\n function length(AddressSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(AddressSet storage set, uint256 index) internal view returns (address) {\n return address(uint160(uint256(_at(set._inner, index))));\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(AddressSet storage set) internal view returns (address[] memory) {\n bytes32[] memory store = _values(set._inner);\n address[] memory result;\n\n assembly {\n result := store\n }\n\n return result;\n }\n\n // UintSet\n\n struct UintSet {\n Set _inner;\n }\n\n /**\n * @dev Add a value to a set. O(1).\n *\n * Returns true if the value was added to the set, that is if it was not\n * already present.\n */\n function add(UintSet storage set, uint256 value) internal returns (bool) {\n return _add(set._inner, bytes32(value));\n }\n\n /**\n * @dev Removes a value from a set. O(1).\n *\n * Returns true if the value was removed from the set, that is if it was\n * present.\n */\n function remove(UintSet storage set, uint256 value) internal returns (bool) {\n return _remove(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns true if the value is in the set. O(1).\n */\n function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n return _contains(set._inner, bytes32(value));\n }\n\n /**\n * @dev Returns the number of values on the set. O(1).\n */\n function length(UintSet storage set) internal view returns (uint256) {\n return _length(set._inner);\n }\n\n /**\n * @dev Returns the value stored at position `index` in the set. O(1).\n *\n * Note that there are no guarantees on the ordering of values inside the\n * array, and it may change when more values are added or removed.\n *\n * Requirements:\n *\n * - `index` must be strictly less than {length}.\n */\n function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n return uint256(_at(set._inner, index));\n }\n\n /**\n * @dev Return the entire set in an array\n *\n * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n */\n function values(UintSet storage set) internal view returns (uint256[] memory) {\n bytes32[] memory store = _values(set._inner);\n uint256[] memory result;\n\n assembly {\n result := store\n }\n\n return result;\n }\n}\n"
},
"vesper-pools/contracts/interfaces/vesper/IGovernable.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\n/**\n * @notice Governable interface\n */\ninterface IGovernable {\n function governor() external view returns (address _governor);\n\n function transferGovernorship(address _proposedGovernor) external;\n}\n"
},
"vesper-pools/contracts/interfaces/vesper/IPausable.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\n/**\n * @notice Pausable interface\n */\ninterface IPausable {\n function paused() external view returns (bool);\n\n function stopEverything() external view returns (bool);\n\n function pause() external;\n\n function unpause() external;\n\n function shutdown() external;\n\n function open() external;\n}\n"
},
"vesper-pools/contracts/interfaces/vesper/IVesperPool.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../../dependencies/openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport \"./IGovernable.sol\";\nimport \"./IPausable.sol\";\n\ninterface IVesperPool is IGovernable, IPausable, IERC20Metadata {\n function calculateUniversalFee(uint256 _profit) external view returns (uint256 _fee);\n\n function deposit(uint256 _share) external;\n\n function multiTransfer(address[] memory _recipients, uint256[] memory _amounts) external returns (bool);\n\n function excessDebt(address _strategy) external view returns (uint256);\n\n function poolAccountant() external view returns (address);\n\n function poolRewards() external view returns (address);\n\n function reportEarning(\n uint256 _profit,\n uint256 _loss,\n uint256 _payback\n ) external;\n\n function reportLoss(uint256 _loss) external;\n\n function sweepERC20(address _fromToken) external;\n\n function withdraw(uint256 _amount) external;\n\n function keepers() external view returns (address[] memory);\n\n function isKeeper(address _address) external view returns (bool);\n\n function maintainers() external view returns (address[] memory);\n\n function isMaintainer(address _address) external view returns (bool);\n\n function pricePerShare() external view returns (uint256);\n\n function strategy(address _strategy)\n external\n view\n returns (\n bool _active,\n uint256 _interestFee, // Obsolete\n uint256 _debtRate, // Obsolete\n uint256 _lastRebalance,\n uint256 _totalDebt,\n uint256 _totalLoss,\n uint256 _totalProfit,\n uint256 _debtRatio,\n uint256 _externalDepositFee\n );\n\n function token() external view returns (IERC20);\n\n function tokensHere() external view returns (uint256);\n\n function totalDebtOf(address _strategy) external view returns (uint256);\n\n function totalValue() external view returns (uint256);\n\n function totalDebt() external view returns (uint256);\n}\n"
},
"vesper-strategies/contracts/interfaces/stargate/IStargateFactory.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\ninterface IStargateFactory {\n function getPool(uint256) external view returns (address);\n\n function allPoolsLength() external view returns (uint256);\n\n function createPool(\n uint256 _poolId,\n address _token,\n uint8 _sharedDecimals,\n uint8 _localDecimals,\n string memory _name,\n string memory _symbol\n ) external view returns (address);\n}\n"
},
"vesper-strategies/contracts/interfaces/stargate/IStargateLpStaking.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\ninterface IStargateLpStaking {\n function deposit(uint256 _pid, uint256 _amount) external;\n\n function withdraw(uint256 _pid, uint256 _amount) external;\n\n function stargate() external view returns (address);\n\n function pendingStargate(uint256 _pid, address _user) external view returns (uint256);\n\n function userInfo(uint256 _pid, address _user) external view returns (uint256 _amount, uint256 _rewardDebt);\n}\n"
},
"vesper-strategies/contracts/interfaces/stargate/IStargatePool.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\ninterface IStargatePool is IERC20 {\n function totalLiquidity() external view returns (uint256);\n\n function token() external view returns (address);\n\n function amountLPtoLD(uint256 _amountLP) external view returns (uint256);\n\n function convertRate() external view returns (uint256);\n}\n"
},
"vesper-strategies/contracts/interfaces/stargate/IStargateRouter.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\ninterface IStargateRouter {\n struct lzTxObj {\n uint256 dstGasForCall;\n uint256 dstNativeAmount;\n bytes dstNativeAddr;\n }\n\n function factory() external view returns (address);\n\n function addLiquidity(\n uint256 _poolId,\n uint256 _amountLD,\n address _to\n ) external;\n\n function swap(\n uint16 _dstChainId,\n uint256 _srcPoolId,\n uint256 _dstPoolId,\n address payable _refundAddress,\n uint256 _amountLD,\n uint256 _minAmountLD,\n lzTxObj memory _lzTxParams,\n bytes calldata _to,\n bytes calldata _payload\n ) external payable;\n\n function redeemRemote(\n uint16 _dstChainId,\n uint256 _srcPoolId,\n uint256 _dstPoolId,\n address payable _refundAddress,\n uint256 _amountLP,\n uint256 _minAmountLD,\n bytes calldata _to,\n lzTxObj memory _lzTxParams\n ) external payable;\n\n function instantRedeemLocal(\n uint16 _srcPoolId,\n uint256 _amountLP,\n address _to\n ) external returns (uint256);\n\n function redeemLocal(\n uint16 _dstChainId,\n uint256 _srcPoolId,\n uint256 _dstPoolId,\n address payable _refundAddress,\n uint256 _amountLP,\n bytes calldata _to,\n lzTxObj memory _lzTxParams\n ) external payable;\n\n function sendCredits(\n uint16 _dstChainId,\n uint256 _srcPoolId,\n uint256 _dstPoolId,\n address payable _refundAddress\n ) external payable;\n\n function quoteLayerZeroFee(\n uint16 _dstChainId,\n uint8 _functionType,\n bytes calldata _toAddress,\n bytes calldata _transferAndCallPayload,\n lzTxObj memory _lzTxParams\n ) external view returns (uint256, uint256);\n}\n"
},
"vesper-strategies/contracts/interfaces/swapper/IRoutedSwapper.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\n/**\n * @notice Routed Swapper interface\n * @dev This contract doesn't support native coins (e.g. ETH, AVAX, MATIC, etc) use wrapper tokens instead\n */\ninterface IRoutedSwapper {\n /**\n * @notice The list of supported DEXes\n * @dev This function is gas intensive\n */\n function getAllExchanges() external view returns (address[] memory);\n\n /**\n * @notice Get *spot* quote\n * It will return the swap amount based on the current reserves of the best pair/path found (i.e. spot price).\n * @dev It shouldn't be used as oracle!!!\n */\n function getAmountIn(\n address tokenIn_,\n address tokenOut_,\n uint256 amountOut_\n ) external returns (uint256 _amountIn);\n\n /**\n * @notice Get *spot* quote\n * It will return the swap amount based on the current reserves of the best pair/path found (i.e. spot price).\n * @dev It shouldn't be used as oracle!!!\n */\n function getAmountOut(\n address tokenIn_,\n address tokenOut_,\n uint256 amountIn_\n ) external returns (uint256 _amountOut);\n\n /**\n * @notice Perform an exact input swap - will revert if there is no default routing\n */\n function swapExactInput(\n address tokenIn_,\n address tokenOut_,\n uint256 amountIn_,\n uint256 amountOutMin_,\n address _receiver\n ) external returns (uint256 _amountOut);\n\n /**\n * @notice Perform an exact output swap - will revert if there is no default routing\n */\n function swapExactOutput(\n address tokenIn_,\n address tokenOut_,\n uint256 amountOut_,\n uint256 amountInMax_,\n address receiver_\n ) external returns (uint256 _amountIn);\n}\n"
},
"vesper-strategies/contracts/strategies/Strategy.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"vesper-pools/contracts/interfaces/vesper/IVesperPool.sol\";\nimport \"vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"vesper-pools/contracts/dependencies/openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/Context.sol\";\nimport \"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/structs/EnumerableSet.sol\";\nimport \"vesper-pools/contracts/dependencies/openzeppelin/contracts/utils/math/Math.sol\";\nimport \"vesper-commons/contracts/interfaces/vesper/IStrategy.sol\";\nimport \"../interfaces/swapper/IRoutedSwapper.sol\";\n\nabstract contract Strategy is IStrategy, Context {\n using SafeERC20 for IERC20;\n using EnumerableSet for EnumerableSet.AddressSet;\n\n IERC20 public immutable collateralToken;\n address public receiptToken;\n address public immutable override pool;\n address public override feeCollector;\n IRoutedSwapper public swapper;\n address internal constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n uint256 internal constant MAX_UINT_VALUE = type(uint256).max;\n\n EnumerableSet.AddressSet private _keepers;\n\n event UpdatedFeeCollector(address indexed previousFeeCollector, address indexed newFeeCollector);\n event UpdatedSwapper(IRoutedSwapper indexed oldSwapper, IRoutedSwapper indexed newSwapper);\n\n constructor(\n address _pool,\n address _swapper,\n address _receiptToken\n ) {\n require(_pool != address(0), \"pool-address-is-zero\");\n require(_swapper != address(0), \"swapper-address-is-zero\");\n swapper = IRoutedSwapper(_swapper);\n pool = _pool;\n collateralToken = IVesperPool(_pool).token();\n receiptToken = _receiptToken;\n require(_keepers.add(_msgSender()), \"add-keeper-failed\");\n }\n\n modifier onlyGovernor() {\n require(_msgSender() == IVesperPool(pool).governor(), \"caller-is-not-the-governor\");\n _;\n }\n\n modifier onlyKeeper() {\n require(_keepers.contains(_msgSender()), \"caller-is-not-a-keeper\");\n _;\n }\n\n modifier onlyPool() {\n require(_msgSender() == pool, \"caller-is-not-vesper-pool\");\n _;\n }\n\n /**\n * @notice Add given address in keepers list.\n * @param _keeperAddress keeper address to add.\n */\n function addKeeper(address _keeperAddress) external onlyGovernor {\n require(_keepers.add(_keeperAddress), \"add-keeper-failed\");\n }\n\n /// @dev Approve all required tokens\n function approveToken() external onlyKeeper {\n _approveToken(0);\n _approveToken(MAX_UINT_VALUE);\n }\n\n /// @notice Check whether given token is reserved or not. Reserved tokens are not allowed to sweep.\n function isReservedToken(address _token) public view virtual override returns (bool);\n\n /// @notice Return list of keepers\n function keepers() external view override returns (address[] memory) {\n return _keepers.values();\n }\n\n /**\n * @notice Migrate all asset and vault ownership,if any, to new strategy\n * @dev _beforeMigration hook can be implemented in child strategy to do extra steps.\n * @param _newStrategy Address of new strategy\n */\n function migrate(address _newStrategy) external virtual override onlyPool {\n require(_newStrategy != address(0), \"new-strategy-address-is-zero\");\n require(IStrategy(_newStrategy).pool() == pool, \"not-valid-new-strategy\");\n _beforeMigration(_newStrategy);\n IERC20(receiptToken).safeTransfer(_newStrategy, IERC20(receiptToken).balanceOf(address(this)));\n collateralToken.safeTransfer(_newStrategy, collateralToken.balanceOf(address(this)));\n }\n\n /**\n * @notice OnlyKeeper: Rebalance profit, loss and investment of this strategy.\n * Calculate profit, loss and payback of this strategy and realize profit/loss and\n * withdraw fund for payback, if any, and submit this report to pool.\n * @return _profit Realized profit in collateral.\n * @return _loss Realized loss, if any, in collateral.\n * @return _payback If strategy has any excess debt, we have to liquidate asset to payback excess debt.\n */\n function rebalance()\n external\n onlyKeeper\n returns (\n uint256 _profit,\n uint256 _loss,\n uint256 _payback\n )\n {\n return _rebalance();\n }\n\n /**\n * @notice Remove given address from keepers list.\n * @param _keeperAddress keeper address to remove.\n */\n function removeKeeper(address _keeperAddress) external onlyGovernor {\n require(_keepers.remove(_keeperAddress), \"remove-keeper-failed\");\n }\n\n /**\n * @notice sweep given token to feeCollector of strategy\n * @param _fromToken token address to sweep\n */\n function sweepERC20(address _fromToken) external override onlyKeeper {\n require(feeCollector != address(0), \"fee-collector-not-set\");\n require(_fromToken != address(collateralToken), \"not-allowed-to-sweep-collateral\");\n require(!isReservedToken(_fromToken), \"not-allowed-to-sweep\");\n if (_fromToken == ETH) {\n Address.sendValue(payable(feeCollector), address(this).balance);\n } else {\n uint256 _amount = IERC20(_fromToken).balanceOf(address(this));\n IERC20(_fromToken).safeTransfer(feeCollector, _amount);\n }\n }\n\n /// @notice Returns address of token correspond to receipt token\n function token() external view override returns (address) {\n return receiptToken;\n }\n\n /// @notice Returns address of token correspond to collateral token\n function collateral() external view override returns (address) {\n return address(collateralToken);\n }\n\n /// @notice Returns total collateral locked in the strategy\n function tvl() external view virtual returns (uint256);\n\n /**\n * @notice Update fee collector\n * @param _feeCollector fee collector address\n */\n function updateFeeCollector(address _feeCollector) external onlyGovernor {\n require(_feeCollector != address(0), \"fee-collector-address-is-zero\");\n require(_feeCollector != feeCollector, \"fee-collector-is-same\");\n emit UpdatedFeeCollector(feeCollector, _feeCollector);\n feeCollector = _feeCollector;\n }\n\n /**\n * @notice Update swapper\n * @param _swapper swapper address\n */\n function updateSwapper(IRoutedSwapper _swapper) external onlyGovernor {\n require(address(_swapper) != address(0), \"swapper-address-is-zero\");\n require(_swapper != swapper, \"swapper-is-same\");\n emit UpdatedSwapper(swapper, _swapper);\n swapper = _swapper;\n }\n\n /**\n * @notice Withdraw collateral token from end protocol.\n * @param _amount Amount of collateral token\n */\n function withdraw(uint256 _amount) external override onlyPool {\n uint256 _collateralHere = collateralToken.balanceOf(address(this));\n if (_collateralHere >= _amount) {\n collateralToken.safeTransfer(pool, _amount);\n } else {\n _withdrawHere(_amount - _collateralHere);\n // Do not assume _withdrawHere() will withdraw exact amount. Check balance again and transfer to pool\n _collateralHere = collateralToken.balanceOf(address(this));\n collateralToken.safeTransfer(pool, Math.min(_amount, _collateralHere));\n }\n }\n\n function _approveToken(uint256 _amount) internal virtual {\n collateralToken.safeApprove(pool, _amount);\n }\n\n /**\n * @dev some strategy may want to prepare before doing migration.\n * Example In Maker old strategy want to give vault ownership to new strategy\n * @param _newStrategy .\n */\n function _beforeMigration(address _newStrategy) internal virtual;\n\n function _rebalance()\n internal\n virtual\n returns (\n uint256 _profit,\n uint256 _loss,\n uint256 _payback\n );\n\n function _swapExactInput(\n address _tokenIn,\n address _tokenOut,\n uint256 _amountIn\n ) internal returns (uint256 _amountOut) {\n _amountOut = swapper.swapExactInput(_tokenIn, _tokenOut, _amountIn, 1, address(this));\n }\n\n function _safeSwapExactInput(\n address _tokenIn,\n address _tokenOut,\n uint256 _amountIn\n ) internal {\n try swapper.swapExactInput(_tokenIn, _tokenOut, _amountIn, 1, address(this)) {} catch {} //solhint-disable no-empty-blocks\n }\n\n // These methods must be implemented by the inheriting strategy\n function _withdrawHere(uint256 _amount) internal virtual;\n}\n"
},
"vesper-strategies/contracts/strategies/stargate/Stargate.sol": {
"content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../../interfaces/stargate/IStargatePool.sol\";\nimport \"../../interfaces/stargate/IStargateRouter.sol\";\nimport \"../../interfaces/stargate/IStargateFactory.sol\";\nimport \"../../interfaces/stargate/IStargateLpStaking.sol\";\nimport \"../Strategy.sol\";\n\n/// @title This Strategy will deposit collateral token in a Stargate Pool\n/// Stake LP Token and accrue swap rewards\ncontract Stargate is Strategy {\n using SafeERC20 for IERC20;\n using SafeERC20 for IStargatePool;\n\n // solhint-disable-next-line var-name-mixedcase\n string public NAME;\n string public constant VERSION = \"5.0.0\";\n\n /// @notice Address of Staking contract (MasterChef V2 behavior)\n IStargateLpStaking public immutable stargateLpStaking;\n /// @notice Reward pool id of the MasterChef\n uint256 public immutable stargateLpStakingPoolId;\n /// @notice Stargate Factory LP Pool Id\n uint256 public immutable stargatePoolId;\n\n /// @notice rewardToken, usually STG\n address public immutable rewardToken;\n\n IStargatePool internal immutable stargateLp;\n\n /// @dev Router to add/remove liquidity from a STG Pool\n IStargateRouter internal immutable stargateRouter;\n\n constructor(\n address pool_,\n address swapper_,\n IStargateRouter stargateRouter_,\n IStargatePool stargateLp_,\n IStargateLpStaking stargateLpStaking_,\n uint256 stargatePoolId_,\n uint256 stargateLpStakingPoolId_,\n string memory name_\n ) Strategy(pool_, swapper_, address(0)) {\n require(address(stargateRouter_) != address(0), \"stg-router-is-zero\");\n require(address(stargateLp_) != address(0), \"stg-lp-pool-is-zero\");\n require(address(stargateLpStaking_) != address(0), \"stg-staking-is-zero\");\n require(stargatePoolId_ > 0, \"stg-pool-is-zero\");\n\n stargateRouter = stargateRouter_;\n stargateLpStaking = IStargateLpStaking(stargateLpStaking_);\n receiptToken = address(stargateLp_);\n stargateLp = stargateLp_;\n stargatePoolId = stargatePoolId_;\n stargateLpStakingPoolId = stargateLpStakingPoolId_; // can be 0\n rewardToken = stargateLpStaking.stargate();\n NAME = name_;\n }\n\n function isReservedToken(address token_) public view override returns (bool) {\n return token_ == receiptToken;\n }\n\n function lpAmountStaked() public view returns (uint256 _lpAmountStaked) {\n (_lpAmountStaked, ) = stargateLpStaking.userInfo(stargateLpStakingPoolId, address(this));\n }\n\n function pendingStargate() external view returns (uint256 _pendingStargate) {\n return stargateLpStaking.pendingStargate(stargateLpStakingPoolId, address(this));\n }\n\n function tvl() external view override returns (uint256) {\n return _getCollateralInStargate() + collateralToken.balanceOf(address(this));\n }\n\n function _approveToken(uint256 _amount) internal virtual override {\n super._approveToken(_amount);\n collateralToken.safeApprove(address(stargateRouter), _amount);\n stargateLp.safeApprove(address(stargateLpStaking), _amount);\n stargateLp.safeApprove(address(stargateRouter), _amount);\n IERC20(rewardToken).safeApprove(address(swapper), _amount);\n }\n\n // solhint-disable-next-line no-empty-blocks\n function _beforeDeposit(uint256 collateralAmount_) internal virtual {}\n\n /**\n * @notice Before migration hook.\n */\n function _beforeMigration(address newStrategy_) internal override {\n require(IStrategy(newStrategy_).token() == receiptToken, \"wrong-receipt-token\");\n stargateLpStaking.withdraw(stargateLpStakingPoolId, lpAmountStaked());\n }\n\n /// @notice Claim rewardToken from LPStaking contract\n function _claimRewardsAndConvertTo(address toToken_) internal {\n // 0 withdraw will trigger rewards claim\n stargateLpStaking.withdraw(stargateLpStakingPoolId, 0);\n uint256 _rewardAmount = IERC20(rewardToken).balanceOf(address(this));\n if (_rewardAmount > 0) {\n _safeSwapExactInput(rewardToken, toToken_, _rewardAmount);\n }\n }\n\n /// @dev Converts a collateral amount in its relative shares of STG LP Token\n function _convertToLpShares(uint256 collateralAmount_) internal view returns (uint256) {\n uint256 _totalLiquidity = stargateLp.totalLiquidity();\n // amount SD = _collateralAmount / stargateLp.convertRate()\n // amount LP = SD * totalSupply / totalLiquidity\n return\n (_totalLiquidity > 0)\n ? ((collateralAmount_ / stargateLp.convertRate()) * stargateLp.totalSupply()) / _totalLiquidity\n : 0;\n }\n\n function _deposit(uint256 collateralAmount_) internal {\n if (collateralAmount_ > 0) {\n _beforeDeposit(collateralAmount_);\n stargateRouter.addLiquidity(stargatePoolId, collateralAmount_, address(this));\n stargateLpStaking.deposit(stargateLpStakingPoolId, stargateLp.balanceOf(address(this)));\n }\n }\n\n /// @dev Gets collateral balance deposited into STG Pool\n function _getCollateralInStargate() internal view returns (uint256 _collateralStaked) {\n return stargateLp.amountLPtoLD(lpAmountStaked() + stargateLp.balanceOf(address(this)));\n }\n\n function _getLpForCollateral(uint256 collateralAmount_) internal returns (uint256) {\n uint256 _lpRequired = _convertToLpShares(collateralAmount_);\n uint256 _lpHere = stargateLp.balanceOf(address(this));\n if (_lpRequired > _lpHere) {\n uint256 _lpAmountStaked = lpAmountStaked();\n uint256 _lpToUnstake = _lpRequired - _lpHere;\n if (_lpToUnstake > _lpAmountStaked) {\n _lpToUnstake = _lpAmountStaked;\n }\n stargateLpStaking.withdraw(stargateLpStakingPoolId, _lpToUnstake);\n return stargateLp.balanceOf(address(this));\n }\n return _lpRequired;\n }\n\n function _rebalance() internal override returns (uint256 _profit, uint256 _loss, uint256 _payback) {\n uint256 _excessDebt = IVesperPool(pool).excessDebt(address(this));\n uint256 _totalDebt = IVesperPool(pool).totalDebtOf(address(this));\n\n // Claim any reward we have.\n _claimRewardsAndConvertTo(address(collateralToken));\n\n uint256 _collateralHere = collateralToken.balanceOf(address(this));\n\n uint256 _totalCollateral = _getCollateralInStargate() + _collateralHere;\n\n if (_totalCollateral > _totalDebt) {\n _profit = _totalCollateral - _totalDebt;\n } else {\n _loss = _totalDebt - _totalCollateral;\n }\n uint256 _profitAndExcessDebt = _profit + _excessDebt;\n if (_profitAndExcessDebt > _collateralHere) {\n _withdrawHere(_profitAndExcessDebt - _collateralHere);\n _collateralHere = collateralToken.balanceOf(address(this));\n }\n\n // Make sure _collateralHere >= _payback + profit. set actual payback first and then profit\n _payback = Math.min(_collateralHere, _excessDebt);\n _profit = _collateralHere > _payback ? Math.min((_collateralHere - _payback), _profit) : 0;\n\n IVesperPool(pool).reportEarning(_profit, _loss, _payback);\n\n // strategy may get new fund. Deposit and stake it to stargate\n _deposit(collateralToken.balanceOf(address(this)));\n }\n\n /// @dev Withdraw collateral here.\n /// @dev This method may withdraw less than requested amount. Caller may need to check balance before and after\n function _withdrawHere(uint256 amount_) internal override {\n uint256 _lpToRedeem = _getLpForCollateral(amount_);\n if (_lpToRedeem > 0) {\n stargateRouter.instantRedeemLocal(uint16(stargatePoolId), _lpToRedeem, address(this));\n }\n }\n\n /************************************************************************************************\n * keeper function *\n ***********************************************************************************************/\n\n /**\n * @notice OnlyKeeper: This function will withdraw required collateral from given\n * destination chain to the chain where this contract is deployed.\n * @param dstChainId_ Destination chainId.\n * @dev Stargate has different chainId than EVM chainId.\n */\n function withdrawForRebalance(uint16 dstChainId_) external payable onlyKeeper {\n // amountToWithdraw is excessDebt of strategy\n uint256 _amountToWithdraw = IVesperPool(pool).excessDebt(address(this));\n uint256 _totalDebt = IVesperPool(pool).totalDebtOf(address(this));\n uint256 _totalCollateral = _getCollateralInStargate();\n\n if (_totalCollateral > _totalDebt) {\n // If we have profit then amountToWithdraw = excessDebt + profit\n _amountToWithdraw += (_totalCollateral - _totalDebt);\n }\n\n uint256 _lpToRedeem = _getLpForCollateral(_amountToWithdraw);\n if (_lpToRedeem > 0) {\n // RedeemLocal will redeem asset from dstChain to this chain and at this address.\n // Also srcPoolId and dstPoolId will be same in this case\n stargateRouter.redeemLocal{value: msg.value}(\n dstChainId_,\n stargatePoolId,\n stargatePoolId,\n payable(msg.sender),\n _lpToRedeem,\n abi.encodePacked(address(this)), // Address which will receive asset\n IStargateRouter.lzTxObj(0, 0, \"0x\") // Basically empty layer zero tx object\n );\n }\n }\n}\n"
}
}
} |