Polygon Sponsored slots available. Book your slot here!
Overview
POL Balance
POL Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Latest 1 internal transaction
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
52560225 | 389 days ago | Contract Creation | 0 POL |
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
Strategy
Compiler Version
v0.8.18+commit.87f61d96
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2024-01-21 */ // SPDX-License-Identifier: GPL-3.0 pragma solidity 0.8.18; // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @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. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol) // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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); /** * @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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); } // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.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); } // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) /** * @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) { return msg.data; } } /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // TokenizedStrategy interface used for internal view delegateCalls. // OpenZeppelin Contracts (last updated v4.8.0) (interfaces/IERC4626.sol) /** * @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626]. * * _Available since v4.7._ */ interface IERC4626 is IERC20, IERC20Metadata { event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares); event Withdraw( address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares ); /** * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing. * * - MUST be an ERC-20 token contract. * - MUST NOT revert. */ function asset() external view returns (address assetTokenAddress); /** * @dev Returns the total amount of the underlying asset that is “managed” by Vault. * * - SHOULD include any compounding that occurs from yield. * - MUST be inclusive of any fees that are charged against assets in the Vault. * - MUST NOT revert. */ function totalAssets() external view returns (uint256 totalManagedAssets); /** * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal * scenario where all the conditions are met. * * - MUST NOT be inclusive of any fees that are charged against assets in the Vault. * - MUST NOT show any variations depending on the caller. * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange. * - MUST NOT revert. * * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and * from. */ function convertToShares(uint256 assets) external view returns (uint256 shares); /** * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal * scenario where all the conditions are met. * * - MUST NOT be inclusive of any fees that are charged against assets in the Vault. * - MUST NOT show any variations depending on the caller. * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange. * - MUST NOT revert. * * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and * from. */ function convertToAssets(uint256 shares) external view returns (uint256 assets); /** * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver, * through a deposit call. * * - MUST return a limited value if receiver is subject to some deposit limit. * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited. * - MUST NOT revert. */ function maxDeposit(address receiver) external view returns (uint256 maxAssets); /** * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given * current on-chain conditions. * * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit * call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called * in the same transaction. * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the * deposit would be accepted, regardless if the user has enough tokens approved, etc. * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees. * - MUST NOT revert. * * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in * share price or some other type of condition, meaning the depositor will lose assets by depositing. */ function previewDeposit(uint256 assets) external view returns (uint256 shares); /** * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens. * * - MUST emit the Deposit event. * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the * deposit execution, and are accounted for during deposit. * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not * approving enough underlying tokens to the Vault contract, etc). * * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token. */ function deposit(uint256 assets, address receiver) external returns (uint256 shares); /** * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call. * - MUST return a limited value if receiver is subject to some mint limit. * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted. * - MUST NOT revert. */ function maxMint(address receiver) external view returns (uint256 maxShares); /** * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given * current on-chain conditions. * * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call * in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the * same transaction. * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint * would be accepted, regardless if the user has enough tokens approved, etc. * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees. * - MUST NOT revert. * * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in * share price or some other type of condition, meaning the depositor will lose assets by minting. */ function previewMint(uint256 shares) external view returns (uint256 assets); /** * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens. * * - MUST emit the Deposit event. * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint * execution, and are accounted for during mint. * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not * approving enough underlying tokens to the Vault contract, etc). * * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token. */ function mint(uint256 shares, address receiver) external returns (uint256 assets); /** * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the * Vault, through a withdraw call. * * - MUST return a limited value if owner is subject to some withdrawal limit or timelock. * - MUST NOT revert. */ function maxWithdraw(address owner) external view returns (uint256 maxAssets); /** * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, * given current on-chain conditions. * * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw * call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if * called * in the same transaction. * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though * the withdrawal would be accepted, regardless if the user has enough shares, etc. * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees. * - MUST NOT revert. * * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in * share price or some other type of condition, meaning the depositor will lose assets by depositing. */ function previewWithdraw(uint256 assets) external view returns (uint256 shares); /** * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver. * * - MUST emit the Withdraw event. * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the * withdraw execution, and are accounted for during withdraw. * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner * not having enough shares, etc). * * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed. * Those methods should be performed separately. */ function withdraw( uint256 assets, address receiver, address owner ) external returns (uint256 shares); /** * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, * through a redeem call. * * - MUST return a limited value if owner is subject to some withdrawal limit or timelock. * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock. * - MUST NOT revert. */ function maxRedeem(address owner) external view returns (uint256 maxShares); /** * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, * given current on-chain conditions. * * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call * in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the * same transaction. * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the * redemption would be accepted, regardless if the user has enough shares, etc. * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees. * - MUST NOT revert. * * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in * share price or some other type of condition, meaning the depositor will lose assets by redeeming. */ function previewRedeem(uint256 shares) external view returns (uint256 assets); /** * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver. * * - MUST emit the Withdraw event. * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the * redeem execution, and are accounted for during redeem. * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner * not having enough shares, etc). * * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed. * Those methods should be performed separately. */ function redeem( uint256 shares, address receiver, address owner ) external returns (uint256 assets); } // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // Interface that implements the 4626 standard and the implementation functions interface ITokenizedStrategy is IERC4626, IERC20Permit { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event UpdatePendingManagement(address indexed newPendingManagement); event UpdateManagement(address indexed newManagement); event UpdateKeeper(address indexed newKeeper); event UpdateEmergencyAdmin(address indexed newEmergencyAdmin); event UpdatePerformanceFee(uint16 newPerformanceFee); event UpdatePerformanceFeeRecipient( address indexed newPerformanceFeeRecipient ); event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime); event StrategyShutdown(); event Reported( uint256 profit, uint256 loss, uint256 protocolFees, uint256 performanceFees ); /*////////////////////////////////////////////////////////////// INITIALIZATION //////////////////////////////////////////////////////////////*/ function init( address _asset, string memory _name, address _management, address _performanceFeeRecipient, address _keeper ) external; /*////////////////////////////////////////////////////////////// NON-STANDARD 4626 OPTIONS //////////////////////////////////////////////////////////////*/ function withdraw( uint256 assets, address receiver, address owner, uint256 maxLoss ) external returns (uint256); function redeem( uint256 shares, address receiver, address owner, uint256 maxLoss ) external returns (uint256); /*////////////////////////////////////////////////////////////// MODIFIERS //////////////////////////////////////////////////////////////*/ function isManagement(address _sender) external view returns (bool); function isKeeperOrManagement(address _sender) external view returns (bool); function isEmergencyAuthorized( address _sender ) external view returns (bool); /*////////////////////////////////////////////////////////////// KEEPERS FUNCTIONS //////////////////////////////////////////////////////////////*/ function tend() external; function report() external returns (uint256 _profit, uint256 _loss); /*////////////////////////////////////////////////////////////// CONSTANTS //////////////////////////////////////////////////////////////*/ function MIN_FEE() external view returns (uint16); function MAX_FEE() external view returns (uint16); function FACTORY() external view returns (address); /*////////////////////////////////////////////////////////////// GETTERS //////////////////////////////////////////////////////////////*/ function apiVersion() external view returns (string memory); function pricePerShare() external view returns (uint256); function totalIdle() external view returns (uint256); function totalDebt() external view returns (uint256); function management() external view returns (address); function pendingManagement() external view returns (address); function keeper() external view returns (address); function emergencyAdmin() external view returns (address); function performanceFee() external view returns (uint16); function performanceFeeRecipient() external view returns (address); function fullProfitUnlockDate() external view returns (uint256); function profitUnlockingRate() external view returns (uint256); function profitMaxUnlockTime() external view returns (uint256); function lastReport() external view returns (uint256); function isShutdown() external view returns (bool); function unlockedShares() external view returns (uint256); /*////////////////////////////////////////////////////////////// SETTERS //////////////////////////////////////////////////////////////*/ function setPendingManagement(address) external; function acceptManagement() external; function setKeeper(address _keeper) external; function setEmergencyAdmin(address _emergencyAdmin) external; function setPerformanceFee(uint16 _performanceFee) external; function setPerformanceFeeRecipient( address _performanceFeeRecipient ) external; function setProfitMaxUnlockTime(uint256 _profitMaxUnlockTime) external; function shutdownStrategy() external; function emergencyWithdraw(uint256 _amount) external; /*////////////////////////////////////////////////////////////// ERC20 ADD ONS //////////////////////////////////////////////////////////////*/ function decreaseAllowance( address spender, uint256 subtractedValue ) external returns (bool); function increaseAllowance( address spender, uint256 addedValue ) external returns (bool); } /** * @title YearnV3 Base Strategy * @author yearn.finance * @notice * BaseStrategy implements all of the required functionality to * seamlessly integrate with the `TokenizedStrategy` implementation contract * allowing anyone to easily build a fully permissionless ERC-4626 compliant * Vault by inheriting this contract and overriding three simple functions. * It utilizes an immutable proxy pattern that allows the BaseStrategy * to remain simple and small. All standard logic is held within the * `TokenizedStrategy` and is reused over any n strategies all using the * `fallback` function to delegatecall the implementation so that strategists * can only be concerned with writing their strategy specific code. * * This contract should be inherited and the three main abstract methods * `_deployFunds`, `_freeFunds` and `_harvestAndReport` implemented to adapt * the Strategy to the particular needs it has to generate yield. There are * other optional methods that can be implemented to further customize * the strategy if desired. * * All default storage for the strategy is controlled and updated by the * `TokenizedStrategy`. The implementation holds a storage struct that * contains all needed global variables in a manual storage slot. This * means strategists can feel free to implement their own custom storage * variables as they need with no concern of collisions. All global variables * can be viewed within the Strategy by a simple call using the * `TokenizedStrategy` variable. IE: TokenizedStrategy.globalVariable();. */ abstract contract BaseStrategy { /*////////////////////////////////////////////////////////////// MODIFIERS //////////////////////////////////////////////////////////////*/ /** * @dev Used on TokenizedStrategy callback functions to make sure it is post * a delegateCall from this address to the TokenizedStrategy. */ modifier onlySelf() { _onlySelf(); _; } /** * @dev Use to assure that the call is coming from the strategies management. */ modifier onlyManagement() { TokenizedStrategy.isManagement(msg.sender); _; } /** * @dev Use to assure that the call is coming from either the strategies * management or the keeper. */ modifier onlyKeepers() { TokenizedStrategy.isKeeperOrManagement(msg.sender); _; } /** * @dev Use to assure that the call is coming from either the strategies * management or the emergency admin. */ modifier onlyEmergencyAuthorized() { TokenizedStrategy.isEmergencyAuthorized(msg.sender); _; } function _onlySelf() internal view { require(msg.sender == address(this), "!self"); } /*////////////////////////////////////////////////////////////// CONSTANTS //////////////////////////////////////////////////////////////*/ /** * This is the address of the TokenizedStrategy implementation * contract that will be used by all strategies to handle the * accounting, logic, storage etc. * * Any external calls to the that don't hit one of the functions * defined in this base or the strategy will end up being forwarded * through the fallback function, which will delegateCall this address. * * This address should be the same for every strategy, never be adjusted * and always be checked before any integration with the Strategy. */ address public constant tokenizedStrategyAddress = 0xDFC8cD9F2f2d306b7C0d109F005DF661E14f4ff2; /*////////////////////////////////////////////////////////////// IMMUTABLES //////////////////////////////////////////////////////////////*/ /** * This variable is set to address(this) during initialization of each strategy. * * This can be used to retrieve storage data within the strategy * contract as if it were a linked library. * * i.e. uint256 totalAssets = TokenizedStrategy.totalAssets() * * Using address(this) will mean any calls using this variable will lead * to a call to itself. Which will hit the fallback function and * delegateCall that to the actual TokenizedStrategy. */ ITokenizedStrategy internal immutable TokenizedStrategy; // Underlying asset the Strategy is earning yield on. // Stored here for cheap retrievals within the strategy. ERC20 internal immutable asset; /** * @notice Used to initialize the strategy on deployment. * * This will set the `TokenizedStrategy` variable for easy * internal view calls to the implementation. As well as * initializing the default storage variables based on the * parameters and using the deployer for the permissioned roles. * * @param _asset Address of the underlying asset. * @param _name Name the strategy will use. */ constructor(address _asset, string memory _name) { asset = ERC20(_asset); // Set instance of the implementation for internal use. TokenizedStrategy = ITokenizedStrategy(address(this)); // Initialize the strategy's storage variables. _delegateCall( abi.encodeCall( ITokenizedStrategy.init, (_asset, _name, msg.sender, msg.sender, msg.sender) ) ); // Store the tokenizedStrategyAddress at the standard implementation // address storage slot so etherscan picks up the interface. This gets // stored on initialization and never updated. assembly { sstore( // keccak256('eip1967.proxy.implementation' - 1) 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, tokenizedStrategyAddress ) } } /*////////////////////////////////////////////////////////////// NEEDED TO BE OVERRIDDEN BY STRATEGIST //////////////////////////////////////////////////////////////*/ /** * @dev Should deploy up to '_amount' of 'asset' in the yield source. * * This function is called at the end of a {deposit} or {mint} * call. Meaning that unless a whitelist is implemented it will * be entirely permissionless and thus can be sandwiched or otherwise * manipulated. * * @param _amount The amount of 'asset' that the strategy should attempt * to deposit in the yield source. */ function _deployFunds(uint256 _amount) internal virtual; /** * @dev Will attempt to free the '_amount' of 'asset'. * * The amount of 'asset' that is already loose has already * been accounted for. * * This function is called during {withdraw} and {redeem} calls. * Meaning that unless a whitelist is implemented it will be * entirely permissionless and thus can be sandwiched or otherwise * manipulated. * * Should not rely on asset.balanceOf(address(this)) calls other than * for diff accounting purposes. * * Any difference between `_amount` and what is actually freed will be * counted as a loss and passed on to the withdrawer. This means * care should be taken in times of illiquidity. It may be better to revert * if withdraws are simply illiquid so not to realize incorrect losses. * * @param _amount, The amount of 'asset' to be freed. */ function _freeFunds(uint256 _amount) internal virtual; /** * @dev Internal function to harvest all rewards, redeploy any idle * funds and return an accurate accounting of all funds currently * held by the Strategy. * * This should do any needed harvesting, rewards selling, accrual, * redepositing etc. to get the most accurate view of current assets. * * NOTE: All applicable assets including loose assets should be * accounted for in this function. * * Care should be taken when relying on oracles or swap values rather * than actual amounts as all Strategy profit/loss accounting will * be done based on this returned value. * * This can still be called post a shutdown, a strategist can check * `TokenizedStrategy.isShutdown()` to decide if funds should be * redeployed or simply realize any profits/losses. * * @return _totalAssets A trusted and accurate account for the total * amount of 'asset' the strategy currently holds including idle funds. */ function _harvestAndReport() internal virtual returns (uint256 _totalAssets); /*////////////////////////////////////////////////////////////// OPTIONAL TO OVERRIDE BY STRATEGIST //////////////////////////////////////////////////////////////*/ /** * @dev Optional function for strategist to override that can * be called in between reports. * * If '_tend' is used tendTrigger() will also need to be overridden. * * This call can only be called by a permissioned role so may be * through protected relays. * * This can be used to harvest and compound rewards, deposit idle funds, * perform needed position maintenance or anything else that doesn't need * a full report for. * * EX: A strategy that can not deposit funds without getting * sandwiched can use the tend when a certain threshold * of idle to totalAssets has been reached. * * The TokenizedStrategy contract will do all needed debt and idle updates * after this has finished and will have no effect on PPS of the strategy * till report() is called. * * @param _totalIdle The current amount of idle funds that are available to deploy. */ function _tend(uint256 _totalIdle) internal virtual {} /** * @dev Optional trigger to override if tend() will be used by the strategy. * This must be implemented if the strategy hopes to invoke _tend(). * * @return . Should return true if tend() should be called by keeper or false if not. */ function _tendTrigger() internal view virtual returns (bool) { return false; } /** * @notice Returns if tend() should be called by a keeper. * * @return . Should return true if tend() should be called by keeper or false if not. * @return . Calldata for the tend call. */ function tendTrigger() external view virtual returns (bool, bytes memory) { return ( // Return the status of the tend trigger. _tendTrigger(), // And the needed calldata either way. abi.encodeWithSelector(ITokenizedStrategy.tend.selector) ); } /** * @notice Gets the max amount of `asset` that an address can deposit. * @dev Defaults to an unlimited amount for any address. But can * be overridden by strategists. * * This function will be called before any deposit or mints to enforce * any limits desired by the strategist. This can be used for either a * traditional deposit limit or for implementing a whitelist etc. * * EX: * if(isAllowed[_owner]) return super.availableDepositLimit(_owner); * * This does not need to take into account any conversion rates * from shares to assets. But should know that any non max uint256 * amounts may be converted to shares. So it is recommended to keep * custom amounts low enough as not to cause overflow when multiplied * by `totalSupply`. * * @param . The address that is depositing into the strategy. * @return . The available amount the `_owner` can deposit in terms of `asset` */ function availableDepositLimit( address /*_owner*/ ) public view virtual returns (uint256) { return type(uint256).max; } /** * @notice Gets the max amount of `asset` that can be withdrawn. * @dev Defaults to an unlimited amount for any address. But can * be overridden by strategists. * * This function will be called before any withdraw or redeem to enforce * any limits desired by the strategist. This can be used for illiquid * or sandwichable strategies. It should never be lower than `totalIdle`. * * EX: * return TokenIzedStrategy.totalIdle(); * * This does not need to take into account the `_owner`'s share balance * or conversion rates from shares to assets. * * @param . The address that is withdrawing from the strategy. * @return . The available amount that can be withdrawn in terms of `asset` */ function availableWithdrawLimit( address /*_owner*/ ) public view virtual returns (uint256) { return type(uint256).max; } /** * @dev Optional function for a strategist to override that will * allow management to manually withdraw deployed funds from the * yield source if a strategy is shutdown. * * This should attempt to free `_amount`, noting that `_amount` may * be more than is currently deployed. * * NOTE: This will not realize any profits or losses. A separate * {report} will be needed in order to record any profit/loss. If * a report may need to be called after a shutdown it is important * to check if the strategy is shutdown during {_harvestAndReport} * so that it does not simply re-deploy all funds that had been freed. * * EX: * if(freeAsset > 0 && !TokenizedStrategy.isShutdown()) { * depositFunds... * } * * @param _amount The amount of asset to attempt to free. */ function _emergencyWithdraw(uint256 _amount) internal virtual {} /*////////////////////////////////////////////////////////////// TokenizedStrategy HOOKS //////////////////////////////////////////////////////////////*/ /** * @notice Should deploy up to '_amount' of 'asset' in yield source. * @dev Callback for the TokenizedStrategy to call during a {deposit} * or {mint} to tell the strategy it can deploy funds. * * Since this can only be called after a {deposit} or {mint} * delegateCall to the TokenizedStrategy msg.sender == address(this). * * Unless a whitelist is implemented this will be entirely permissionless * and thus can be sandwiched or otherwise manipulated. * * @param _amount The amount of 'asset' that the strategy should * attempt to deposit in the yield source. */ function deployFunds(uint256 _amount) external virtual onlySelf { _deployFunds(_amount); } /** * @notice Will attempt to free the '_amount' of 'asset'. * @dev Callback for the TokenizedStrategy to call during a withdraw * or redeem to free the needed funds to service the withdraw. * * This can only be called after a 'withdraw' or 'redeem' delegateCall * to the TokenizedStrategy so msg.sender == address(this). * * @param _amount The amount of 'asset' that the strategy should attempt to free up. */ function freeFunds(uint256 _amount) external virtual onlySelf { _freeFunds(_amount); } /** * @notice Returns the accurate amount of all funds currently * held by the Strategy. * @dev Callback for the TokenizedStrategy to call during a report to * get an accurate accounting of assets the strategy controls. * * This can only be called after a report() delegateCall to the * TokenizedStrategy so msg.sender == address(this). * * @return . A trusted and accurate account for the total amount * of 'asset' the strategy currently holds including idle funds. */ function harvestAndReport() external virtual onlySelf returns (uint256) { return _harvestAndReport(); } /** * @notice Will call the internal '_tend' when a keeper tends the strategy. * @dev Callback for the TokenizedStrategy to initiate a _tend call in the strategy. * * This can only be called after a tend() delegateCall to the TokenizedStrategy * so msg.sender == address(this). * * We name the function `tendThis` so that `tend` calls are forwarded to * the TokenizedStrategy so it can do the necessary accounting. * @param _totalIdle The amount of current idle funds that can be * deployed during the tend */ function tendThis(uint256 _totalIdle) external virtual onlySelf { _tend(_totalIdle); } /** * @notice Will call the internal '_emergencyWithdraw' function. * @dev Callback for the TokenizedStrategy during an emergency withdraw. * * This can only be called after a emergencyWithdraw() delegateCall to * the TokenizedStrategy so msg.sender == address(this). * * We name the function `shutdownWithdraw` so that `emergencyWithdraw` * calls are forwarded to the TokenizedStrategy so it can do the necessary * accounting after the withdraw. * * @param _amount The amount of asset to attempt to free. */ function shutdownWithdraw(uint256 _amount) external virtual onlySelf { _emergencyWithdraw(_amount); } /** * @dev Function used to delegate call the TokenizedStrategy with * certain `_calldata` and return any return values. * * This is used to setup the initial storage of the strategy, and * can be used by strategist to forward any other call to the * TokenizedStrategy implementation. * * @param _calldata The abi encoded calldata to use in delegatecall. * @return . The return value if the call was successful in bytes. */ function _delegateCall( bytes memory _calldata ) internal returns (bytes memory) { // Delegate call the tokenized strategy with provided calldata. (bool success, bytes memory result) = tokenizedStrategyAddress .delegatecall(_calldata); // If the call reverted. Return the error. if (!success) { assembly { let ptr := mload(0x40) let size := returndatasize() returndatacopy(ptr, 0, size) revert(ptr, size) } } // Return the result. return result; } // execute a function on the TokenizedStrategy and return any value. fallback() external { // load our target address address _tokenizedStrategyAddress = tokenizedStrategyAddress; // Execute external function using delegatecall and return any value. assembly { // Copy function selector and any arguments. calldatacopy(0, 0, calldatasize()) // Execute function delegatecall. let result := delegatecall( gas(), _tokenizedStrategyAddress, 0, calldatasize(), 0, 0 ) // Get any return value returndatacopy(0, 0, returndatasize()) // Return any return value or error back to the caller switch result case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } } /** * @title Base Health Check * @author Yearn.finance * @notice This contract can be inherited by any Yearn * V3 strategy wishing to implement a health check during * the `report` function in order to prevent any unexpected * behavior from being permanently recorded as well as the * `checkHealth` modifier. * * A strategist simply needs to inherit this contract. Set * the limit ratios to the desired amounts and then * override `_harvestAndReport()` just as they otherwise * would. If the profit or loss that would be recorded is * outside the acceptable bounds the tx will revert. * * The healthcheck does not prevent a strategy from reporting * losses, but rather can make sure manual intervention is * needed before reporting an unexpected loss or profit. */ abstract contract BaseHealthCheck is BaseStrategy { // Can be used to determine if a healthcheck should be called. // Defaults to true; bool public doHealthCheck = true; uint256 internal constant MAX_BPS = 10_000; // Default profit limit to 100%. uint256 private _profitLimitRatio = MAX_BPS; // Defaults loss limit to 0. uint256 private _lossLimitRatio; constructor( address _asset, string memory _name ) BaseStrategy(_asset, _name) {} /** * @notice Returns the current profit limit ratio. * @dev Use a getter function to keep the variable private. * @return . The current profit limit ratio. */ function profitLimitRatio() public view returns (uint256) { return _profitLimitRatio; } /** * @notice Returns the current loss limit ratio. * @dev Use a getter function to keep the variable private. * @return . The current loss limit ratio. */ function lossLimitRatio() public view returns (uint256) { return _lossLimitRatio; } /** * @notice Set the `profitLimitRatio`. * @dev Denominated in basis points. I.E. 1_000 == 10%. * @param _newProfitLimitRatio The mew profit limit ratio. */ function setProfitLimitRatio( uint256 _newProfitLimitRatio ) external onlyManagement { _setProfitLimitRatio(_newProfitLimitRatio); } /** * @dev Internally set the profit limit ratio. Denominated * in basis points. I.E. 1_000 == 10%. * @param _newProfitLimitRatio The mew profit limit ratio. */ function _setProfitLimitRatio(uint256 _newProfitLimitRatio) internal { require(_newProfitLimitRatio > 0, "!zero profit"); _profitLimitRatio = _newProfitLimitRatio; } /** * @notice Set the `lossLimitRatio`. * @dev Denominated in basis points. I.E. 1_000 == 10%. * @param _newLossLimitRatio The new loss limit ratio. */ function setLossLimitRatio( uint256 _newLossLimitRatio ) external onlyManagement { _setLossLimitRatio(_newLossLimitRatio); } /** * @dev Internally set the loss limit ratio. Denominated * in basis points. I.E. 1_000 == 10%. * @param _newLossLimitRatio The new loss limit ratio. */ function _setLossLimitRatio(uint256 _newLossLimitRatio) internal { require(_newLossLimitRatio < MAX_BPS, "!loss limit"); _lossLimitRatio = _newLossLimitRatio; } /** * @notice Turns the healthcheck on and off. * @dev If turned off the next report will auto turn it back on. * @param _doHealthCheck Bool if healthCheck should be done. */ function setDoHealthCheck(bool _doHealthCheck) public onlyManagement { doHealthCheck = _doHealthCheck; } /** * @notice OVerrides the default {harvestAndReport} to include a healthcheck. * @return _totalAssets New totalAssets post report. */ function harvestAndReport() external override onlySelf returns (uint256 _totalAssets) { // Let the strategy report. _totalAssets = _harvestAndReport(); // Run the healthcheck on the amount returned. _executeHealthCheck(_totalAssets); } /** * @dev To be called during a report to make sure the profit * or loss being recorded is within the acceptable bound. * * @param _newTotalAssets The amount that will be reported. */ function _executeHealthCheck(uint256 _newTotalAssets) internal virtual { if (!doHealthCheck) { doHealthCheck = true; return; } // Get the current total assets from the implementation. uint256 currentTotalAssets = TokenizedStrategy.totalAssets(); if (_newTotalAssets > currentTotalAssets) { require( ((_newTotalAssets - currentTotalAssets) <= (currentTotalAssets * _profitLimitRatio) / MAX_BPS), "healthCheck" ); } else if (currentTotalAssets > _newTotalAssets) { require( (currentTotalAssets - _newTotalAssets <= ((currentTotalAssets * _lossLimitRatio) / MAX_BPS)), "healthCheck" ); } } } // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol) // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "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"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // 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 /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } interface IAjnaPool { /** * @notice Called by lenders to add an amount of credit at a specified price bucket. * @param amount_ The amount of quote token to be added by a lender (`WAD` precision). * @param index_ The index of the bucket to which the quote tokens will be added. * @param expiry_ Timestamp after which this transaction will revert, preventing inclusion in a block with unfavorable price. * @return bucketLP_ The amount of `LP` changed for the added quote tokens (`WAD` precision). * @return addedAmount_ The amount of quote token added (`WAD` precision). */ function addQuoteToken( uint256 amount_, uint256 index_, uint256 expiry_ ) external returns (uint256 bucketLP_, uint256 addedAmount_); /** * @notice Called by lenders to move an amount of credit from a specified price bucket to another specified price bucket. * @param maxAmount_ The maximum amount of quote token to be moved by a lender (`WAD` precision). * @param fromIndex_ The bucket index from which the quote tokens will be removed. * @param toIndex_ The bucket index to which the quote tokens will be added. * @param expiry_ Timestamp after which this transaction will revert, preventing inclusion in a block with unfavorable price. * @return fromBucketLP_ The amount of `LP` moved out from bucket (`WAD` precision). * @return toBucketLP_ The amount of `LP` moved to destination bucket (`WAD` precision). * @return movedAmount_ The amount of quote token moved (`WAD` precision). */ function moveQuoteToken( uint256 maxAmount_, uint256 fromIndex_, uint256 toIndex_, uint256 expiry_ ) external returns ( uint256 fromBucketLP_, uint256 toBucketLP_, uint256 movedAmount_ ); /** * @notice Called by lenders to remove an amount of credit at a specified price bucket. * @param maxAmount_ The max amount of quote token to be removed by a lender (`WAD` precision). * @param index_ The bucket index from which quote tokens will be removed. * @return removedAmount_ The amount of quote token removed (`WAD` precision). * @return redeemedLP_ The amount of `LP` used for removing quote tokens amount (`WAD` precision). */ function removeQuoteToken( uint256 maxAmount_, uint256 index_ ) external returns (uint256 removedAmount_, uint256 redeemedLP_); /** * @notice Called by lenders to claim collateral from a price bucket. * @param maxAmount_ The amount of collateral (`WAD` precision for `ERC20` pools, number of `NFT` tokens for `ERC721` pools) to claim. * @param index_ The bucket index from which collateral will be removed. * @return removedAmount_ The amount of collateral removed (`WAD` precision). * @return redeemedLP_ The amount of `LP` used for removing collateral amount (`WAD` precision). */ function removeCollateral( uint256 maxAmount_, uint256 index_ ) external returns (uint256 removedAmount_, uint256 redeemedLP_); /** * @notice Returns the address of the pool's quote token. */ function quoteTokenAddress() external pure returns (address); /** * @notice Deposit claimable collateral into a specified bucket. * @param amountToAdd_ Amount of collateral to deposit (`WAD` precision). * @param index_ The bucket index to which collateral will be deposited. * @param expiry_ Timestamp after which this transaction will revert, preventing inclusion in a block with unfavorable price. * @return bucketLP_ The amount of `LP` awarded for the added collateral (`WAD` precision). */ function addCollateral( uint256 amountToAdd_, uint256 index_, uint256 expiry_ ) external returns (uint256 bucketLP_); /** * @notice Returns pool related debt values. * @return debt_ Current amount of debt owed by borrowers in pool. * @return accruedDebt_ Debt owed by borrowers based on last inflator snapshot. * @return debtInAuction_ Total amount of debt in auction. * @return t0Debt2ToCollateral_ t0debt accross all borrowers divided by their collateral, used in determining a collateralization weighted debt. */ function debtInfo() external view returns ( uint256 debt_, uint256 accruedDebt_, uint256 debtInAuction_, uint256 t0Debt2ToCollateral_ ); /** * @notice Returns the bucket index for a given debt amount. * @param debt_ The debt amount to calculate bucket index for (`WAD` precision). * @return Bucket index. */ function depositIndex(uint256 debt_) external view returns (uint256); } /** * The `TokenizedStrategy` variable can be used to retrieve the strategies * specific storage data your contract. * * i.e. uint256 totalAssets = TokenizedStrategy.totalAssets() * * This can not be used for write functions. Any TokenizedStrategy * variables that need to be updated post deployment will need to * come from an external call from the strategies specific `management`. */ // NOTE: To implement permissioned functions you can use the onlyManagement, onlyEmergencyAuthorized and onlyKeepers modifiers contract Strategy is BaseHealthCheck { using SafeERC20 for ERC20; address internal constant GOV = 0xC4ad0000E223E398DC329235e6C497Db5470B626; address internal constant SMS = 0x16388000546eDed4D476bd2A4A374B5a16125Bc1; IAjnaPool public pool; uint256 public index; uint256 trackedAmount; address depositor; constructor( address _asset, address _pool, string memory _name ) BaseHealthCheck(_asset, _name) { pool = IAjnaPool(_pool); require(pool.quoteTokenAddress() == _asset, "!PoolToken"); ERC20(_asset).safeApprove(address(pool), type(uint256).max); } /*////////////////////////////////////////////////////////////// NEEDED TO BE OVERRIDDEN BY STRATEGIST //////////////////////////////////////////////////////////////*/ /** * @dev Should deploy up to '_amount' of 'asset' in the yield source. * * This function is called at the end of a {deposit} or {mint} * call. Meaning that unless a whitelist is implemented it will * be entirely permissionless and thus can be sandwiched or otherwise * manipulated. * * @param _amount The amount of 'asset' that the strategy should attempt * to deposit in the yield source. */ function _deployFunds(uint256 _amount) internal override { // This method is not used since we would deposit to the pool through // `addLiquidity()` } /** * @dev Will attempt to free the '_amount' of 'asset'. * * The amount of 'asset' that is already loose has already * been accounted for. * * This function is called during {withdraw} and {redeem} calls. * Meaning that unless a whitelist is implemented it will be * entirely permissionless and thus can be sandwiched or otherwise * manipulated. * * Should not rely on asset.balanceOf(address(this)) calls other than * for diff accounting purposes. * * Any difference between `_amount` and what is actually freed will be * counted as a loss and passed on to the withdrawer. This means * care should be taken in times of illiquidity. It may be better to revert * if withdraws are simply illiquid so not to realize incorrect losses. * * @param _amount, The amount of 'asset' to be freed. */ function _freeFunds(uint256 _amount) internal override { // Will not be used. Strategy will allocate 100% of funds // until `removeLiquidity()` is called } /** * @dev Internal function to harvest all rewards, redeploy any idle * funds and return an accurate accounting of all funds currently * held by the Strategy. * * This should do any needed harvesting, rewards selling, accrual, * redepositing etc. to get the most accurate view of current assets. * * NOTE: All applicable assets including loose assets should be * accounted for in this function. * * Care should be taken when relying on oracles or swap values rather * than actual amounts as all Strategy profit/loss accounting will * be done based on this returned value. * * This can still be called post a shutdown, a strategist can check * `TokenizedStrategy.isShutdown()` to decide if funds should be * redeployed or simply realize any profits/losses. * * @return _totalAssets A trusted and accurate account for the total * amount of 'asset' the strategy currently holds including idle funds. */ function _harvestAndReport() internal override returns (uint256 _totalAssets) { _totalAssets = balanceOfWant() + trackedAmount; } function _onlyVaultManagers() internal view { require( msg.sender == TokenizedStrategy.management() || msg.sender == SMS || msg.sender == GOV ); } modifier onlyVaultManagers() { _onlyVaultManagers(); _; } function addLiquidity( uint256 _amount, uint256 _index ) external onlyVaultManagers { trackedAmount += _amount; index = _index; pool.addQuoteToken(_amount, _index, block.timestamp); } function removeLiquidity( uint256 _amount, uint256 _index ) external onlyVaultManagers { _removeLiquidity(_amount, _index); } function _removeLiquidity(uint256 _amount, uint256 _index) internal { pool.removeQuoteToken(_amount, _index); if (_amount < trackedAmount) { trackedAmount -= _amount; } else { trackedAmount = 0; index = 0; } } function moveLiquidity( uint256 _amount, uint256 _fromIndex, uint256 _toIndex ) external onlyVaultManagers { pool.moveQuoteToken(_amount, _fromIndex, _toIndex, block.timestamp); index = _toIndex; } function removeCollateral( uint256 _amount, uint256 _index ) external onlyVaultManagers { pool.removeCollateral(_amount, _index); } /* * Called by keeper when market price > lup */ function moveToLup(uint256 _amount) external onlyKeepers { // Calculate lup (uint256 debt, , , ) = pool.debtInfo(); require(debt > 0); uint256 newIndex = pool.depositIndex(debt); require(index != newIndex); pool.moveQuoteToken(_amount, index, newIndex, block.timestamp); index = newIndex; } /* * Called by keeper when market price <= lup and we want to exit asap */ function fastExit(uint256 _amount) external onlyKeepers { _removeLiquidity(_amount, index); } function sweep(address _token, uint256 _amount) external { require(msg.sender == GOV); require(address(asset) != _token); ERC20 _asset = ERC20(_token); _asset.transfer(GOV, _amount); } function balanceOfWant() internal view returns (uint256) { return ERC20(asset).balanceOf(address(this)); } /*////////////////////////////////////////////////////////////// OPTIONAL TO OVERRIDE BY STRATEGIST //////////////////////////////////////////////////////////////*/ /** * @dev Optional function for strategist to override that can * be called in between reports. * * If '_tend' is used tendTrigger() will also need to be overridden. * * This call can only be called by a permissioned role so may be * through protected relays. * * This can be used to harvest and compound rewards, deposit idle funds, * perform needed position maintenance or anything else that doesn't need * a full report for. * * EX: A strategy that can not deposit funds without getting * sandwiched can use the tend when a certain threshold * of idle to totalAssets has been reached. * * The TokenizedStrategy contract will do all needed debt and idle updates * after this has finished and will have no effect on PPS of the strategy * till report() is called. * * @param _totalIdle The current amount of idle funds that are available to deploy. * function _tend(uint256 _totalIdle) internal override {} */ /** * @dev Optional trigger to override if tend() will be used by the strategy. * This must be implemented if the strategy hopes to invoke _tend(). * * @return . Should return true if tend() should be called by keeper or false if not. * function _tendTrigger() internal view override returns (bool) {} */ /** * @notice Gets the max amount of `asset` that an address can deposit. * @dev Defaults to an unlimited amount for any address. But can * be overridden by strategists. * * This function will be called before any deposit or mints to enforce * any limits desired by the strategist. This can be used for either a * traditional deposit limit or for implementing a whitelist etc. * * EX: * if(isAllowed[_owner]) return super.availableDepositLimit(_owner); * * This does not need to take into account any conversion rates * from shares to assets. But should know that any non max uint256 * amounts may be converted to shares. So it is recommended to keep * custom amounts low enough as not to cause overflow when multiplied * by `totalSupply`. * * @param . The address that is depositing into the strategy. * @return . The available amount the `_owner` can deposit in terms of `asset` * */ function availableDepositLimit( address _owner ) public view override returns (uint256) { if (_owner == depositor) { return type(uint256).max; } return 0; } function setDepositor(address _depositor) external onlyManagement { depositor = _depositor; } /** * @notice Gets the max amount of `asset` that can be withdrawn. * @dev Defaults to an unlimited amount for any address. But can * be overridden by strategists. * * This function will be called before any withdraw or redeem to enforce * any limits desired by the strategist. This can be used for illiquid * or sandwichable strategies. It should never be lower than `totalIdle`. * * EX: * return TokenIzedStrategy.totalIdle(); * * This does not need to take into account the `_owner`'s share balance * or conversion rates from shares to assets. * * @param . The address that is withdrawing from the strategy. * @return . The available amount that can be withdrawn in terms of `asset` * */ function availableWithdrawLimit( address /* _owner */ ) public view override returns (uint256) { return Math.min(TokenizedStrategy.totalIdle(), balanceOfWant()); } /** * @dev Optional function for a strategist to override that will * allow management to manually withdraw deployed funds from the * yield source if a strategy is shutdown. * * This should attempt to free `_amount`, noting that `_amount` may * be more than is currently deployed. * * NOTE: This will not realize any profits or losses. A separate * {report} will be needed in order to record any profit/loss. If * a report may need to be called after a shutdown it is important * to check if the strategy is shutdown during {_harvestAndReport} * so that it does not simply re-deploy all funds that had been freed. * * EX: * if(freeAsset > 0 && !TokenizedStrategy.isShutdown()) { * depositFunds... * } * * @param _amount The amount of asset to attempt to free. * function _emergencyWithdraw(uint256 _amount) internal override { TODO: If desired implement simple logic to free deployed funds. EX: _amount = min(_amount, aToken.balanceOf(address(this))); _freeFunds(_amount); } */ } interface IBaseStrategy { function tokenizedStrategyAddress() external view returns (address); /*////////////////////////////////////////////////////////////// IMMUTABLE FUNCTIONS //////////////////////////////////////////////////////////////*/ function availableDepositLimit( address _owner ) external view returns (uint256); function availableWithdrawLimit( address _owner ) external view returns (uint256); function deployFunds(uint256 _assets) external; function freeFunds(uint256 _amount) external; function harvestAndReport() external returns (uint256); function tendThis(uint256 _totalIdle) external; function shutdownWithdraw(uint256 _amount) external; function tendTrigger() external view returns (bool, bytes memory); } interface IStrategy is IBaseStrategy, ITokenizedStrategy {} interface IStrategyInterface is IStrategy { function addLiquidity(uint256 _amount, uint256 _index) external; function removeLiquidity(uint256 _amount, uint256 _index) external; function moveLiquidity( uint256 _amount, uint256 _fromIndex, uint256 _toIndex ) external; function removeCollateral(uint256 _amount, uint256 _index) external; function sweep(address _token, uint256 _amount) external; function pool() external view returns (address); function index() external view returns (uint256); function setDepositor(address _depositor) external; function moveToLup(uint256 _amount) external; function fastExit(uint256 _amount) external; } contract AjnaStrategyFactory { address public management; address public sms; event AjnaStrategy(address indexed strategy, address indexed pool); constructor(address _management, address _sms) { management = _management; sms = _sms; } function newAjnaStrategy( address _asset, address _pool, string memory _name, address _vault, address _keeper ) external returns (address) { IStrategyInterface newStrategy = IStrategyInterface( address(new Strategy(address(_asset), _pool, _name)) ); newStrategy.setProfitMaxUnlockTime(0); newStrategy.setPerformanceFee(500); newStrategy.setDepositor(_vault); newStrategy.setPerformanceFeeRecipient(_vault); newStrategy.setPendingManagement(management); newStrategy.setEmergencyAdmin(sms); newStrategy.setKeeper(_keeper); emit AjnaStrategy(address(newStrategy), _pool); return address(newStrategy); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"address","name":"_pool","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"addLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"availableDepositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"availableWithdrawLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deployFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"doHealthCheck","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"fastExit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"freeFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestAndReport","outputs":[{"internalType":"uint256","name":"_totalAssets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"index","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lossLimitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_fromIndex","type":"uint256"},{"internalType":"uint256","name":"_toIndex","type":"uint256"}],"name":"moveLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"moveToLup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pool","outputs":[{"internalType":"contract IAjnaPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"profitLimitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"removeCollateral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"removeLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_depositor","type":"address"}],"name":"setDepositor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_doHealthCheck","type":"bool"}],"name":"setDoHealthCheck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newLossLimitRatio","type":"uint256"}],"name":"setLossLimitRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newProfitLimitRatio","type":"uint256"}],"name":"setProfitLimitRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"shutdownWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"sweep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_totalIdle","type":"uint256"}],"name":"tendThis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tendTrigger","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenizedStrategyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa84174000000000000000000000000fc230c275423ec3b0e627805275a4288502e765800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000012616a6e612d7976757364632d612d757364630000000000000000000000000000
-----Decoded View---------------
Arg [0] : _asset (address): 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174
Arg [1] : _pool (address): 0xfc230C275423Ec3b0e627805275A4288502E7658
Arg [2] : _name (string): ajna-yvusdc-a-usdc
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000002791bca1f2de4661ed88a30c99a7a9449aa84174
Arg [1] : 000000000000000000000000fc230c275423ec3b0e627805275a4288502e7658
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [4] : 616a6e612d7976757364632d612d757364630000000000000000000000000000
Deployed Bytecode Sourcemap
95116:11463:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54076:42;69738:14;69487:33;;69719:34;70000:1;69980;69947:14;69927:1;69883:25;69859:5;69828:188;70088:16;70085:1;70082;70067:38;70194:6;70214:68;;;;70333:16;70330:1;70323:27;70214:68;70250:16;70247:1;70240:27;70187:178;;105206:191;;;;;;:::i;:::-;;:::i;:::-;;;548:25:1;;;536:2;521:18;105206:191:0;;;;;;;;95358:21;;;;;-1:-1:-1;;;;;95358:21:0;;;;;;-1:-1:-1;;;;;766:32:1;;;748:51;;736:2;721:18;95358:21:0;584:221:1;95386:20:0;;;;;;66035:100;;;;;;:::i;:::-;;:::i;104054:217::-;;;;;;:::i;:::-;;:::i;74274:319::-;;;:::i;71929:101::-;72005:17;;71929:101;;61182:318;61425:56;;;;;;;;;;;;;;;;-1:-1:-1;;;;;61425:56:0;-1:-1:-1;;;61425:56:0;;;61182:318;;;;-1:-1:-1;;61182:318:0;:::i;71372:32::-;;;;;;;;;;;;1993:14:1;;1986:22;1968:41;;1956:2;1941:18;71372:32:0;1828:187:1;100223:168:0;;;;;;:::i;:::-;;:::i;101042:227::-;;;;;;:::i;:::-;;:::i;100927:107::-;;;;;;:::i;:::-;;:::i;72223:97::-;72297:15;;72223:97;;72515:160;;;;;;:::i;:::-;;:::i;99250:238::-;;;;;;:::i;:::-;;:::i;99496:162::-;;;;;;:::i;:::-;;:::i;73989:118::-;;;;;;:::i;:::-;;:::i;100465:362::-;;;;;;:::i;:::-;;:::i;54016:102::-;;54076:42;54016:102;;73250:152;;;;;;:::i;:::-;;:::i;99963:252::-;;;;;;:::i;:::-;;:::i;104279:107::-;;;;;;:::i;:::-;;:::i;105206:191::-;105306:7;105333:56;105342:17;-1:-1:-1;;;;;105342:27:0;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;105373:15;:13;:15::i;:::-;105333:8;:56::i;:::-;105326:63;105206:191;-1:-1:-1;;105206:191:0:o;66035:100::-;52396:11;:9;:11::i;:::-;66035:100;:::o;104054:217::-;104181:9;;104147:7;;-1:-1:-1;;;;;104181:9:0;;;104171:19;;;;104167:76;;-1:-1:-1;;;104214:17:0;104054:217;-1:-1:-1;104054:217:0:o;104167:76::-;-1:-1:-1;104262:1:0;;104054:217;-1:-1:-1;104054:217:0:o;74274:319::-;74374:20;52396:11;:9;:11::i;:::-;74464:19:::1;:17;:19::i;:::-;74449:34;;74552:33;74572:12;74552:19;:33::i;:::-;74274:319:::0;:::o;100223:168::-;99202:20;:18;:20::i;:::-;100345:4:::1;::::0;:38:::1;::::0;-1:-1:-1;;;100345:38:0;;::::1;::::0;::::1;3854:25:1::0;;;3895:18;;;3888:34;;;-1:-1:-1;;;;;100345:4:0;;::::1;::::0;:21:::1;::::0;3827:18:1;;100345:38:0::1;;::::0;::::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;100223:168:::0;;:::o;101042:227::-;101118:10;95226:42;101118:17;101110:26;;;;;;101173:6;-1:-1:-1;;;;;101155:24:0;101163:5;-1:-1:-1;;;;;101155:24:0;;101147:33;;;;;;101232:29;;-1:-1:-1;;;101232:29:0;;95226:42;101232:29;;;4357:51:1;4424:18;;;4417:34;;;101214:6:0;;-1:-1:-1;;;;;101232:15:0;;;;;4330:18:1;;101232:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;100927:107::-;52807:50;;-1:-1:-1;;;52807:50:0;;52846:10;52807:50;;;748:51:1;52807:17:0;-1:-1:-1;;;;;52807:38:0;;;;721:18:1;;52807:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;100994:32:::1;101011:7;101020:5;;100994:16;:32::i;72515:160::-:0;52573:42;;-1:-1:-1;;;52573:42:0;;52604:10;52573:42;;;748:51:1;52573:17:0;-1:-1:-1;;;;;52573:30:0;;;;721:18:1;;52573:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;72625::::1;72646:20;72625;:42::i;99250:238::-:0;99202:20;:18;:20::i;:::-;99385:7:::1;99368:13;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;99403:5:0::1;:14:::0;;;99428:4:::1;::::0;:52:::1;::::0;-1:-1:-1;;;99428:52:0;;;;::::1;5176:25:1::0;;;5217:18;;;5210:34;;;99464:15:0::1;5260:18:1::0;;;5253:34;-1:-1:-1;;;;;99428:4:0::1;::::0;:18:::1;::::0;5149::1;;99428:52:0::1;4974:319:1::0;99496:162:0;99202:20;:18;:20::i;:::-;99617:33:::1;99634:7;99643:6;99617:16;:33::i;:::-;99496:162:::0;;:::o;73989:118::-;52573:42;;-1:-1:-1;;;52573:42:0;;52604:10;52573:42;;;748:51:1;52573:17:0;-1:-1:-1;;;;;52573:30:0;;;;721:18:1;;52573:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;74069:13:0::1;:30:::0;;-1:-1:-1;;74069:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;73989:118::o;100465:362::-;52807:50;;-1:-1:-1;;;52807:50:0;;52846:10;52807:50;;;748:51:1;52807:17:0;-1:-1:-1;;;;;52807:38:0;;;;721:18:1;;52807:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;100582:4:0::1;::::0;:15:::1;::::0;;-1:-1:-1;;;100582:15:0;;;;100560:12:::1;::::0;-1:-1:-1;;;;;100582:4:0::1;::::0;:13:::1;::::0;:15:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;:4;:15:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;100559:38;;;;;100623:1;100616:4;:8;100608:17;;;::::0;::::1;;100657:4;::::0;:23:::1;::::0;-1:-1:-1;;;100657:23:0;;::::1;::::0;::::1;548:25:1::0;;;100638:16:0::1;::::0;-1:-1:-1;;;;;100657:4:0::1;::::0;:17:::1;::::0;521:18:1;;100657:23:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;100638:42;;100708:8;100699:5;;:17:::0;100691:26:::1;;;::::0;::::1;;100730:4;::::0;100759:5:::1;::::0;;100730:62:::1;::::0;-1:-1:-1;;;100730:62:0;;;;::::1;5902:25:1::0;;;5943:18;;;5936:34;5986:18;;;5979:34;;;100776:15:0::1;6029:18:1::0;;;6022:34;-1:-1:-1;;;;;100730:4:0;;::::1;::::0;:19:::1;::::0;5874::1;;100730:62:0::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;100803:5:0::1;:16:::0;-1:-1:-1;;100465:362:0:o;73250:152::-;52573:42;;-1:-1:-1;;;52573:42:0;;52604:10;52573:42;;;748:51:1;52573:17:0;-1:-1:-1;;;;;52573:30:0;;;;721:18:1;;52573:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;73356:38:::1;73375:18;73356;:38::i;99963:252::-:0;99202:20;:18;:20::i;:::-;100113:4:::1;::::0;:67:::1;::::0;-1:-1:-1;;;100113:67:0;;::::1;::::0;::::1;5902:25:1::0;;;5943:18;;;5936:34;;;5986:18;;;5979:34;;;100164:15:0::1;6029:18:1::0;;;6022:34;-1:-1:-1;;;;;100113:4:0;;::::1;::::0;:19:::1;::::0;5874::1;;100113:67:0::1;5671:391:1::0;104279:107:0;52573:42;;-1:-1:-1;;;52573:42:0;;52604:10;52573:42;;;748:51:1;52573:17:0;-1:-1:-1;;;;;52573:30:0;;;;721:18:1;;52573:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;104356:9:0::1;:22:::0;;-1:-1:-1;;;;;;104356:22:0::1;-1:-1:-1::0;;;;;104356:22:0;;;::::1;::::0;;;::::1;::::0;;104279:107::o;86366:616::-;86730:10;;;86729:62;;-1:-1:-1;86746:39:0;;-1:-1:-1;;;86746:39:0;;86770:4;86746:39;;;6590:34:1;-1:-1:-1;;;;;6660:15:1;;;6640:18;;;6633:43;86746:15:0;;;;;6525:18:1;;86746:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;86729:62;86707:166;;;;-1:-1:-1;;;86707:166:0;;6889:2:1;86707:166:0;;;6871:21:1;6928:2;6908:18;;;6901:30;6967:34;6947:18;;;6940:62;-1:-1:-1;;;7018:18:1;;;7011:52;7080:19;;86707:166:0;;;;;;;;;86911:62;;;-1:-1:-1;;;;;4375:32:1;;86911:62:0;;;4357:51:1;4424:18;;;;4417:34;;;86911:62:0;;;;;;;;;;4330:18:1;;;;86911:62:0;;;;;;;;-1:-1:-1;;;;;86911:62:0;-1:-1:-1;;;86911:62:0;;;86884:90;;86904:5;;86884:19;:90::i;:::-;86366:616;;;:::o;79666:229::-;79803:12;79835:52;79857:6;79865:4;79871:1;79874:12;79835:21;:52::i;:::-;79828:59;79666:229;-1:-1:-1;;;;79666:229:0:o;101277:120::-;101352:37;;-1:-1:-1;;;101352:37:0;;101383:4;101352:37;;;748:51:1;101325:7:0;;101358:5;-1:-1:-1;;;;;101352:22:0;;;;721:18:1;;101352:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;101345:44;;101277:120;:::o;617:106::-;675:7;706:1;702;:5;:13;;714:1;702:13;;;710:1;702:13;695:20;617:106;-1:-1:-1;;;617:106:0:o;53149:99::-;53203:10;53225:4;53203:27;53195:45;;;;-1:-1:-1;;;53195:45:0;;7312:2:1;53195:45:0;;;7294:21:1;7351:1;7331:18;;;7324:29;-1:-1:-1;;;7369:18:1;;;7362:35;7414:18;;53195:45:0;7110:328:1;53195:45:0;53149:99::o;98755:175::-;98838:20;98909:13;;98891:15;:13;:15::i;:::-;:31;;;;:::i;74821:846::-;74908:13;;;;74903:88;;-1:-1:-1;74938:13:0;:20;;-1:-1:-1;;74938:20:0;74954:4;74938:20;;;74821:846::o;74903:88::-;75069:26;75098:17;-1:-1:-1;;;;;75098:29:0;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;75069:60;;75164:18;75146:15;:36;75142:518;;;71449:6;75311:17;;75290:18;:38;;;;:::i;:::-;75289:50;;;;:::i;:::-;75227:36;75245:18;75227:15;:36;:::i;:::-;75226:113;;75199:188;;;;-1:-1:-1;;;75199:188:0;;8173:2:1;75199:188:0;;;8155:21:1;8212:2;8192:18;;;8185:30;-1:-1:-1;;;8231:18:1;;;8224:41;8282:18;;75199:188:0;7971:335:1;75142:518:0;75430:15;75409:18;:36;75405:255;;;71449:6;75573:15;;75552:18;:36;;;;:::i;:::-;75551:48;;;;:::i;:::-;75489:36;75510:15;75489:18;:36;:::i;98938:216::-;99029:17;-1:-1:-1;;;;;99029:28:0;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;99015:44:0;:10;-1:-1:-1;;;;;99015:44:0;;:82;;;-1:-1:-1;99080:10:0;95307:42;99080:17;99015:82;:120;;;-1:-1:-1;99118:10:0;95226:42;99118:17;99015:120;98993:153;;;;;99666:289;99745:4;;:38;;-1:-1:-1;;;99745:38:0;;;;;3854:25:1;;;3895:18;;;3888:34;;;-1:-1:-1;;;;;99745:4:0;;;;:21;;3827:18:1;;99745:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;99808:13;;99798:7;:23;99794:154;;;99855:7;99838:13;;:24;;;;;;;:::i;:::-;;;;-1:-1:-1;99794:154:0;;-1:-1:-1;99794:154:0;;99911:1;99895:13;:17;;;99927:5;:9;99666:289;;:::o;72873:188::-;72984:1;72961:20;:24;72953:49;;;;-1:-1:-1;;;72953:49:0;;8769:2:1;72953:49:0;;;8751:21:1;8808:2;8788:18;;;8781:30;-1:-1:-1;;;8827:18:1;;;8820:42;8879:18;;72953:49:0;8567:336:1;72953:49:0;73013:17;:40;72873:188::o;73594:183::-;71449:6;73678:18;:28;73670:52;;;;-1:-1:-1;;;73670:52:0;;9110:2:1;73670:52:0;;;9092:21:1;9149:2;9129:18;;;9122:30;-1:-1:-1;;;9168:18:1;;;9161:41;9219:18;;73670:52:0;8908:335:1;73670:52:0;73733:15;:36;73594:183::o;88697:716::-;89121:23;89147:69;89175:4;89147:69;;;;;;;;;;;;;;;;;89155:5;-1:-1:-1;;;;;89147:27:0;;;:69;;;;;:::i;:::-;89231:17;;89121:95;;-1:-1:-1;89231:21:0;89227:179;;89328:10;89317:30;;;;;;;;;;;;:::i;:::-;89309:85;;;;-1:-1:-1;;;89309:85:0;;9450:2:1;89309:85:0;;;9432:21:1;9489:2;9469:18;;;9462:30;9528:34;9508:18;;;9501:62;-1:-1:-1;;;9579:18:1;;;9572:40;9629:19;;89309:85:0;9248:406:1;80786:455:0;80956:12;81014:5;80989:21;:30;;80981:81;;;;-1:-1:-1;;;80981:81:0;;9861:2:1;80981:81:0;;;9843:21:1;9900:2;9880:18;;;9873:30;9939:34;9919:18;;;9912:62;-1:-1:-1;;;9990:18:1;;;9983:36;10036:19;;80981:81:0;9659:402:1;80981:81:0;81074:12;81088:23;81115:6;-1:-1:-1;;;;;81115:11:0;81134:5;81141:4;81115:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81073:73;;;;81164:69;81191:6;81199:7;81208:10;81220:12;81164:26;:69::i;:::-;81157:76;80786:455;-1:-1:-1;;;;;;;80786:455:0:o;83359:644::-;83544:12;83573:7;83569:427;;;83601:10;:17;83622:1;83601:22;83597:290;;-1:-1:-1;;;;;77204:19:0;;;83811:60;;;;-1:-1:-1;;;83811:60:0;;10560:2:1;83811:60:0;;;10542:21:1;10599:2;10579:18;;;10572:30;10638:31;10618:18;;;10611:59;10687:18;;83811:60:0;10358:353:1;83811:60:0;-1:-1:-1;83908:10:0;83901:17;;83569:427;83951:33;83959:10;83971:12;84706:17;;:21;84702:388;;84938:10;84932:17;84995:15;84982:10;84978:2;84974:19;84967:44;84702:388;85065:12;85058:20;;-1:-1:-1;;;85058:20:0;;;;;;;;:::i;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:247;209:6;262:2;250:9;241:7;237:23;233:32;230:52;;;278:1;275;268:12;230:52;317:9;304:23;336:31;361:5;336:31;:::i;810:180::-;869:6;922:2;910:9;901:7;897:23;893:32;890:52;;;938:1;935;928:12;890:52;-1:-1:-1;961:23:1;;810:180;-1:-1:-1;810:180:1:o;995:250::-;1080:1;1090:113;1104:6;1101:1;1098:13;1090:113;;;1180:11;;;1174:18;1161:11;;;1154:39;1126:2;1119:10;1090:113;;;-1:-1:-1;;1237:1:1;1219:16;;1212:27;995:250::o;1250:270::-;1291:3;1329:5;1323:12;1356:6;1351:3;1344:19;1372:76;1441:6;1434:4;1429:3;1425:14;1418:4;1411:5;1407:16;1372:76;:::i;:::-;1502:2;1481:15;-1:-1:-1;;1477:29:1;1468:39;;;;1509:4;1464:50;;1250:270;-1:-1:-1;;1250:270:1:o;1525:298::-;1708:6;1701:14;1694:22;1683:9;1676:41;1753:2;1748;1737:9;1733:18;1726:30;1657:4;1773:44;1813:2;1802:9;1798:18;1790:6;1773:44;:::i;2020:248::-;2088:6;2096;2149:2;2137:9;2128:7;2124:23;2120:32;2117:52;;;2165:1;2162;2155:12;2117:52;-1:-1:-1;;2188:23:1;;;2258:2;2243:18;;;2230:32;;-1:-1:-1;2020:248:1:o;2273:315::-;2341:6;2349;2402:2;2390:9;2381:7;2377:23;2373:32;2370:52;;;2418:1;2415;2408:12;2370:52;2457:9;2444:23;2476:31;2501:5;2476:31;:::i;:::-;2526:5;2578:2;2563:18;;;;2550:32;;-1:-1:-1;;;2273:315:1:o;2593:118::-;2679:5;2672:13;2665:21;2658:5;2655:32;2645:60;;2701:1;2698;2691:12;2716:241;2772:6;2825:2;2813:9;2804:7;2800:23;2796:32;2793:52;;;2841:1;2838;2831:12;2793:52;2880:9;2867:23;2899:28;2921:5;2899:28;:::i;3170:316::-;3247:6;3255;3263;3316:2;3304:9;3295:7;3291:23;3287:32;3284:52;;;3332:1;3329;3322:12;3284:52;-1:-1:-1;;3355:23:1;;;3425:2;3410:18;;3397:32;;-1:-1:-1;3476:2:1;3461:18;;;3448:32;;3170:316;-1:-1:-1;3170:316:1:o;3491:184::-;3561:6;3614:2;3602:9;3593:7;3589:23;3585:32;3582:52;;;3630:1;3627;3620:12;3582:52;-1:-1:-1;3653:16:1;;3491:184;-1:-1:-1;3491:184:1:o;3933:245::-;4012:6;4020;4073:2;4061:9;4052:7;4048:23;4044:32;4041:52;;;4089:1;4086;4079:12;4041:52;-1:-1:-1;;4112:16:1;;4168:2;4153:18;;;4147:25;4112:16;;4147:25;;-1:-1:-1;3933:245:1:o;4462:::-;4529:6;4582:2;4570:9;4561:7;4557:23;4553:32;4550:52;;;4598:1;4595;4588:12;4550:52;4630:9;4624:16;4649:28;4671:5;4649:28;:::i;4712:127::-;4773:10;4768:3;4764:20;4761:1;4754:31;4804:4;4801:1;4794:15;4828:4;4825:1;4818:15;4844:125;4909:9;;;4930:10;;;4927:36;;;4943:18;;:::i;5298:368::-;5395:6;5403;5411;5419;5472:3;5460:9;5451:7;5447:23;5443:33;5440:53;;;5489:1;5486;5479:12;5440:53;-1:-1:-1;;5512:16:1;;5568:2;5553:18;;5547:25;5612:2;5597:18;;5591:25;5656:2;5641:18;;;5635:25;5512:16;;5547:25;;-1:-1:-1;5635:25:1;;-1:-1:-1;5298:368:1;-1:-1:-1;5298:368:1:o;6067:306::-;6155:6;6163;6171;6224:2;6212:9;6203:7;6199:23;6195:32;6192:52;;;6240:1;6237;6230:12;6192:52;6269:9;6263:16;6253:26;;6319:2;6308:9;6304:18;6298:25;6288:35;;6363:2;6352:9;6348:18;6342:25;6332:35;;6067:306;;;;;:::o;7443:168::-;7516:9;;;7547;;7564:15;;;7558:22;;7544:37;7534:71;;7585:18;;:::i;7616:217::-;7656:1;7682;7672:132;;7726:10;7721:3;7717:20;7714:1;7707:31;7761:4;7758:1;7751:15;7789:4;7786:1;7779:15;7672:132;-1:-1:-1;7818:9:1;;7616:217::o;7838:128::-;7905:9;;;7926:11;;;7923:37;;;7940:18;;:::i;8311:251::-;8381:6;8434:2;8422:9;8413:7;8409:23;8405:32;8402:52;;;8450:1;8447;8440:12;8402:52;8482:9;8476:16;8501:31;8526:5;8501:31;:::i;10066:287::-;10195:3;10233:6;10227:13;10249:66;10308:6;10303:3;10296:4;10288:6;10284:17;10249:66;:::i;:::-;10331:16;;;;;10066:287;-1:-1:-1;;10066:287:1:o;10716:219::-;10865:2;10854:9;10847:21;10828:4;10885:44;10925:2;10914:9;10910:18;10902:6;10885:44;:::i
Swarm Source
ipfs://501546dcf8c0dc7b5491054abd06c98332de9db81869cc805b58cf557d8c9763
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
[ 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.