{"file_path":"src/Staker.sol","creation_status":"success","source_code":"// SPDX-License-Identifier: AGPL-3.0\npragma solidity 0.8.23;\n\nimport {IVault} from \"@yearn-vaults/interfaces/IVault.sol\";\nimport {BaseHealthCheck, BaseStrategy} from \"@periphery/Bases/HealthCheck/BaseHealthCheck.sol\";\n\nimport {IAccountant} from \"./interfaces/IAccountant.sol\";\n\ncontract LV2SPStakerStrategy is BaseHealthCheck {\n\n // ===============================================================\n // Constants\n // ===============================================================\n\n /// @notice The accountant of the vault, from which we claim rewards\n IAccountant public immutable ACCOUNTANT;\n\n // ===============================================================\n // Constructor\n // ===============================================================\n\n /// @param _vault Address of the strategy's underlying vault\n /// @param _name Name of the strategy\n constructor(address _vault, string memory _name) BaseHealthCheck(_vault, _name) {\n ACCOUNTANT = IAccountant(IVault(_vault).accountant());\n require(address(ACCOUNTANT) != address(0), \"!accountant\");\n }\n\n // ===============================================================\n // Internal mutated functions\n // ===============================================================\n\n /// @inheritdoc BaseStrategy\n function _deployFunds(\n uint256 /*_amount*/\n ) internal pure override {\n return;\n }\n\n /// @inheritdoc BaseStrategy\n function _freeFunds(\n uint256 /*_amount*/\n ) internal pure override {\n return;\n }\n\n /// @inheritdoc BaseStrategy\n function _harvestAndReport() internal override returns (uint256 _totalAssets) {\n ACCOUNTANT.distribute(address(asset)); // Claim yBOLD\n\n // Return total balance\n _totalAssets = asset.balanceOf(address(this));\n }\n\n}\n","deployed_bytecode":"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","optimization_enabled":false,"verified_twin_address_hash":null,"is_verified":true,"compiler_settings":{"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":false,"runs":200},"remappings":[":@openzeppelin/=lib/openzeppelin-contracts/",":@periphery/=lib/tokenized-strategy-periphery/src/",":@tokenized-strategy/=lib/tokenized-strategy/src/",":@vault-periphery/=lib/vault-periphery/src/",":@yearn-vaults/=lib/yearn-vaults-v3/contracts/",":ds-test/=lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/tokenized-strategy/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":openzeppelin/=lib/openzeppelin-contracts/contracts/",":tokenized-strategy 2/=lib/tokenized-strategy-periphery/lib/tokenized-strategy 2/src/",":tokenized-strategy-periphery/=lib/tokenized-strategy-periphery/",":tokenized-strategy/=lib/tokenized-strategy/",":vault-periphery/=lib/vault-periphery/",":yearn-vaults-v3 2/=lib/tokenized-strategy-periphery/lib/",":yearn-vaults-v3/=lib/yearn-vaults-v3/"]},"optimization_runs":null,"sourcify_repo_url":"https://repo.sourcify.dev/contracts/full_match/1/0x23346B04a7f55b8760E5860AA5A77383D63491cD/","decoded_constructor_args":[["0x9F4330700a36B29952869fac9b33f45EEdd8A3d8",{"internalType":"address","name":"_vault","type":"address"}],["Staked yBOLD",{"internalType":"string","name":"_name","type":"string"}]],"compiler_version":"0.8.23+commit.f704f362","is_verified_via_verifier_alliance":false,"verified_at":"2025-06-10T02:37:02.665817Z","implementations":[{"address_hash":"0xD377919FA87120584B21279a491F82D5265A139c","name":"TokenizedStrategy"}],"proxy_type":"eip1967","external_libraries":[],"creation_bytecode":"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","name":"LV2SPStakerStrategy","is_blueprint":false,"license_type":"none","is_fully_verified":true,"is_verified_via_eth_bytecode_db":true,"language":"solidity","evm_version":"shanghai","can_be_visualized_via_sol2uml":true,"is_verified_via_sourcify":true,"additional_sources":[{"file_path":"lib/openzeppelin-contracts/contracts/interfaces/IERC4626.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC4626.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../token/ERC20/IERC20.sol\";\nimport \"../token/ERC20/extensions/IERC20Metadata.sol\";\n\n/**\n * @dev Interface of the ERC4626 \"Tokenized Vault Standard\", as defined in\n * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].\n *\n * _Available since v4.7._\n */\ninterface IERC4626 is IERC20, IERC20Metadata {\n\n event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);\n\n event Withdraw(\n address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares\n );\n\n /**\n * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\n *\n * - MUST be an ERC-20 token contract.\n * - MUST NOT revert.\n */\n function asset() external view returns (address assetTokenAddress);\n\n /**\n * @dev Returns the total amount of the underlying asset that is “managed” by Vault.\n *\n * - SHOULD include any compounding that occurs from yield.\n * - MUST be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT revert.\n */\n function totalAssets() external view returns (uint256 totalManagedAssets);\n\n /**\n * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\n * scenario where all the conditions are met.\n *\n * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT show any variations depending on the caller.\n * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\n * - MUST NOT revert.\n *\n * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the\n * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and\n * from.\n */\n function convertToShares(\n uint256 assets\n ) external view returns (uint256 shares);\n\n /**\n * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\n * scenario where all the conditions are met.\n *\n * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\n * - MUST NOT show any variations depending on the caller.\n * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\n * - MUST NOT revert.\n *\n * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the\n * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and\n * from.\n */\n function convertToAssets(\n uint256 shares\n ) external view returns (uint256 assets);\n\n /**\n * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\n * through a deposit call.\n *\n * - MUST return a limited value if receiver is subject to some deposit limit.\n * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\n * - MUST NOT revert.\n */\n function maxDeposit(\n address receiver\n ) external view returns (uint256 maxAssets);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\n * current on-chain conditions.\n *\n * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\n * call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\n * in the same transaction.\n * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\n * deposit would be accepted, regardless if the user has enough tokens approved, etc.\n * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by depositing.\n */\n function previewDeposit(\n uint256 assets\n ) external view returns (uint256 shares);\n\n /**\n * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\n *\n * - MUST emit the Deposit event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * deposit execution, and are accounted for during deposit.\n * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\n * approving enough underlying tokens to the Vault contract, etc).\n *\n * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.\n */\n function deposit(uint256 assets, address receiver) external returns (uint256 shares);\n\n /**\n * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\n * - MUST return a limited value if receiver is subject to some mint limit.\n * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\n * - MUST NOT revert.\n */\n function maxMint(\n address receiver\n ) external view returns (uint256 maxShares);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\n * current on-chain conditions.\n *\n * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\n * in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\n * same transaction.\n * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\n * would be accepted, regardless if the user has enough tokens approved, etc.\n * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by minting.\n */\n function previewMint(\n uint256 shares\n ) external view returns (uint256 assets);\n\n /**\n * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\n *\n * - MUST emit the Deposit event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\n * execution, and are accounted for during mint.\n * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\n * approving enough underlying tokens to the Vault contract, etc).\n *\n * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.\n */\n function mint(uint256 shares, address receiver) external returns (uint256 assets);\n\n /**\n * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\n * Vault, through a withdraw call.\n *\n * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\n * - MUST NOT revert.\n */\n function maxWithdraw(\n address owner\n ) external view returns (uint256 maxAssets);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\n * given current on-chain conditions.\n *\n * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\n * call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\n * called\n * in the same transaction.\n * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\n * the withdrawal would be accepted, regardless if the user has enough shares, etc.\n * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by depositing.\n */\n function previewWithdraw(\n uint256 assets\n ) external view returns (uint256 shares);\n\n /**\n * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\n *\n * - MUST emit the Withdraw event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * withdraw execution, and are accounted for during withdraw.\n * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\n * not having enough shares, etc).\n *\n * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\n * Those methods should be performed separately.\n */\n function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\n\n /**\n * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\n * through a redeem call.\n *\n * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\n * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\n * - MUST NOT revert.\n */\n function maxRedeem(\n address owner\n ) external view returns (uint256 maxShares);\n\n /**\n * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\n * given current on-chain conditions.\n *\n * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\n * in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\n * same transaction.\n * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\n * redemption would be accepted, regardless if the user has enough shares, etc.\n * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\n * - MUST NOT revert.\n *\n * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\n * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\n */\n function previewRedeem(\n uint256 shares\n ) external view returns (uint256 assets);\n\n /**\n * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\n *\n * - MUST emit the Withdraw event.\n * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\n * redeem execution, and are accounted for during redeem.\n * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\n * not having enough shares, etc).\n *\n * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\n * Those methods should be performed separately.\n */\n function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\n\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n\n mapping(address => uint256) private _balances;\n\n mapping(address => mapping(address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the default value returned by this function, unless\n * it's overridden.\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(\n address account\n ) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `to` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address to, uint256 amount) public virtual override returns (bool) {\n address owner = _msgSender();\n _transfer(owner, to, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n * `transferFrom`. This is semantically equivalent to an infinite approval.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n address owner = _msgSender();\n _approve(owner, spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * NOTE: Does not update the allowance if the current allowance\n * is the maximum `uint256`.\n *\n * Requirements:\n *\n * - `from` and `to` cannot be the zero address.\n * - `from` must have a balance of at least `amount`.\n * - the caller must have allowance for ``from``'s tokens of at least\n * `amount`.\n */\n function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n address spender = _msgSender();\n _spendAllowance(from, spender, amount);\n _transfer(from, to, amount);\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n address owner = _msgSender();\n _approve(owner, spender, allowance(owner, spender) + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n address owner = _msgSender();\n uint256 currentAllowance = allowance(owner, spender);\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n unchecked {\n _approve(owner, spender, currentAllowance - subtractedValue);\n }\n\n return true;\n }\n\n /**\n * @dev Moves `amount` of tokens from `from` to `to`.\n *\n * This internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `from` cannot be the zero address.\n * - `to` cannot be the zero address.\n * - `from` must have a balance of at least `amount`.\n */\n function _transfer(address from, address to, uint256 amount) internal virtual {\n require(from != address(0), \"ERC20: transfer from the zero address\");\n require(to != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(from, to, amount);\n\n uint256 fromBalance = _balances[from];\n require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n unchecked {\n _balances[from] = fromBalance - amount;\n // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n // decrementing then incrementing.\n _balances[to] += amount;\n }\n\n emit Transfer(from, to, amount);\n\n _afterTokenTransfer(from, to, amount);\n }\n\n /**\n * @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n unchecked {\n // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n _balances[account] += amount;\n }\n emit Transfer(address(0), account, amount);\n\n _afterTokenTransfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n unchecked {\n _balances[account] = accountBalance - amount;\n // Overflow not possible: amount <= accountBalance <= totalSupply.\n _totalSupply -= amount;\n }\n\n emit Transfer(account, address(0), amount);\n\n _afterTokenTransfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(address owner, address spender, uint256 amount) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n *\n * Does not update the allowance amount in case of infinite allowance.\n * Revert if not enough allowance is available.\n *\n * Might emit an {Approval} event.\n */\n function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n uint256 currentAllowance = allowance(owner, spender);\n if (currentAllowance != type(uint256).max) {\n require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n unchecked {\n _approve(owner, spender, currentAllowance - amount);\n }\n }\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n /**\n * @dev Hook that is called after any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * has been transferred to `to`.\n * - when `from` is zero, `amount` tokens have been minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(\n address account\n ) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `to`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address to, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(address from, address to, uint256 amount) external returns (bool);\n\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n * doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n * token.safeTransferFrom(msg.sender, address(this), value);\n * ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\n *\n * CAUTION: See Security Considerations above.\n */\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(\n address owner\n ) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n}\n"},{"file_path":"lib/openzeppelin-contracts/contracts/utils/Context.sol","source_code":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n\n function _contextSuffixLength() internal view virtual returns (uint256) {\n return 0;\n }\n\n}\n"},{"file_path":"lib/tokenized-strategy-periphery/src/Bases/HealthCheck/BaseHealthCheck.sol","source_code":"// SPDX-License-Identifier: AGPL-3.0\npragma solidity >=0.8.18;\n\nimport {BaseStrategy, ERC20} from \"@tokenized-strategy/BaseStrategy.sol\";\n\n/**\n * @title Base Health Check\n * @author Yearn.finance\n * @notice This contract can be inherited by any Yearn\n * V3 strategy wishing to implement a health check during\n * the `report` function in order to prevent any unexpected\n * behavior from being permanently recorded as well as the\n * `checkHealth` modifier.\n *\n * A strategist simply needs to inherit this contract. Set\n * the limit ratios to the desired amounts and then\n * override `_harvestAndReport()` just as they otherwise\n * would. If the profit or loss that would be recorded is\n * outside the acceptable bounds the tx will revert.\n *\n * The healthcheck does not prevent a strategy from reporting\n * losses, but rather can make sure manual intervention is\n * needed before reporting an unexpected loss or profit.\n */\nabstract contract BaseHealthCheck is BaseStrategy {\n\n // Can be used to determine if a healthcheck should be called.\n // Defaults to true;\n bool public doHealthCheck = true;\n\n uint256 internal constant MAX_BPS = 10_000;\n\n // Default profit limit to 100%.\n uint16 private _profitLimitRatio = uint16(MAX_BPS);\n\n // Defaults loss limit to 0.\n uint16 private _lossLimitRatio;\n\n constructor(address _asset, string memory _name) BaseStrategy(_asset, _name) {}\n\n /**\n * @notice Returns the current profit limit ratio.\n * @dev Use a getter function to keep the variable private.\n * @return . The current profit limit ratio.\n */\n function profitLimitRatio() public view returns (uint256) {\n return _profitLimitRatio;\n }\n\n /**\n * @notice Returns the current loss limit ratio.\n * @dev Use a getter function to keep the variable private.\n * @return . The current loss limit ratio.\n */\n function lossLimitRatio() public view returns (uint256) {\n return _lossLimitRatio;\n }\n\n /**\n * @notice Set the `profitLimitRatio`.\n * @dev Denominated in basis points. I.E. 1_000 == 10%.\n * @param _newProfitLimitRatio The mew profit limit ratio.\n */\n function setProfitLimitRatio(\n uint256 _newProfitLimitRatio\n ) external onlyManagement {\n _setProfitLimitRatio(_newProfitLimitRatio);\n }\n\n /**\n * @dev Internally set the profit limit ratio. Denominated\n * in basis points. I.E. 1_000 == 10%.\n * @param _newProfitLimitRatio The mew profit limit ratio.\n */\n function _setProfitLimitRatio(\n uint256 _newProfitLimitRatio\n ) internal {\n require(_newProfitLimitRatio > 0, \"!zero profit\");\n require(_newProfitLimitRatio <= type(uint16).max, \"!too high\");\n _profitLimitRatio = uint16(_newProfitLimitRatio);\n }\n\n /**\n * @notice Set the `lossLimitRatio`.\n * @dev Denominated in basis points. I.E. 1_000 == 10%.\n * @param _newLossLimitRatio The new loss limit ratio.\n */\n function setLossLimitRatio(\n uint256 _newLossLimitRatio\n ) external onlyManagement {\n _setLossLimitRatio(_newLossLimitRatio);\n }\n\n /**\n * @dev Internally set the loss limit ratio. Denominated\n * in basis points. I.E. 1_000 == 10%.\n * @param _newLossLimitRatio The new loss limit ratio.\n */\n function _setLossLimitRatio(\n uint256 _newLossLimitRatio\n ) internal {\n require(_newLossLimitRatio < MAX_BPS, \"!loss limit\");\n _lossLimitRatio = uint16(_newLossLimitRatio);\n }\n\n /**\n * @notice Turns the healthcheck on and off.\n * @dev If turned off the next report will auto turn it back on.\n * @param _doHealthCheck Bool if healthCheck should be done.\n */\n function setDoHealthCheck(\n bool _doHealthCheck\n ) public onlyManagement {\n doHealthCheck = _doHealthCheck;\n }\n\n /**\n * @notice OVerrides the default {harvestAndReport} to include a healthcheck.\n * @return _totalAssets New totalAssets post report.\n */\n function harvestAndReport() external override onlySelf returns (uint256 _totalAssets) {\n // Let the strategy report.\n _totalAssets = _harvestAndReport();\n\n // Run the healthcheck on the amount returned.\n _executeHealthCheck(_totalAssets);\n }\n\n /**\n * @dev To be called during a report to make sure the profit\n * or loss being recorded is within the acceptable bound.\n *\n * @param _newTotalAssets The amount that will be reported.\n */\n function _executeHealthCheck(\n uint256 _newTotalAssets\n ) internal virtual {\n if (!doHealthCheck) {\n doHealthCheck = true;\n return;\n }\n\n // Get the current total assets from the implementation.\n uint256 currentTotalAssets = TokenizedStrategy.totalAssets();\n\n if (_newTotalAssets > currentTotalAssets) {\n require(\n ((_newTotalAssets - currentTotalAssets) <= (currentTotalAssets * uint256(_profitLimitRatio)) / MAX_BPS),\n \"healthCheck\"\n );\n } else if (currentTotalAssets > _newTotalAssets) {\n require(\n (currentTotalAssets - _newTotalAssets <= ((currentTotalAssets * uint256(_lossLimitRatio)) / MAX_BPS)),\n \"healthCheck\"\n );\n }\n }\n\n}\n"},{"file_path":"lib/tokenized-strategy/src/BaseStrategy.sol","source_code":"// SPDX-License-Identifier: AGPL-3.0\npragma solidity >=0.8.18;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\n// TokenizedStrategy interface used for internal view delegateCalls.\nimport {ITokenizedStrategy} from \"./interfaces/ITokenizedStrategy.sol\";\n\n/**\n * @title YearnV3 Base Strategy\n * @author yearn.finance\n * @notice\n * BaseStrategy implements all of the required functionality to\n * seamlessly integrate with the `TokenizedStrategy` implementation contract\n * allowing anyone to easily build a fully permissionless ERC-4626 compliant\n * Vault by inheriting this contract and overriding three simple functions.\n *\n * It utilizes an immutable proxy pattern that allows the BaseStrategy\n * to remain simple and small. All standard logic is held within the\n * `TokenizedStrategy` and is reused over any n strategies all using the\n * `fallback` function to delegatecall the implementation so that strategists\n * can only be concerned with writing their strategy specific code.\n *\n * This contract should be inherited and the three main abstract methods\n * `_deployFunds`, `_freeFunds` and `_harvestAndReport` implemented to adapt\n * the Strategy to the particular needs it has to generate yield. There are\n * other optional methods that can be implemented to further customize\n * the strategy if desired.\n *\n * All default storage for the strategy is controlled and updated by the\n * `TokenizedStrategy`. The implementation holds a storage struct that\n * contains all needed global variables in a manual storage slot. This\n * means strategists can feel free to implement their own custom storage\n * variables as they need with no concern of collisions. All global variables\n * can be viewed within the Strategy by a simple call using the\n * `TokenizedStrategy` variable. IE: TokenizedStrategy.globalVariable();.\n */\nabstract contract BaseStrategy {\n\n /*//////////////////////////////////////////////////////////////\n MODIFIERS\n //////////////////////////////////////////////////////////////*/\n /**\n * @dev Used on TokenizedStrategy callback functions to make sure it is post\n * a delegateCall from this address to the TokenizedStrategy.\n */\n modifier onlySelf() {\n _onlySelf();\n _;\n }\n\n /**\n * @dev Use to assure that the call is coming from the strategies management.\n */\n modifier onlyManagement() {\n TokenizedStrategy.requireManagement(msg.sender);\n _;\n }\n\n /**\n * @dev Use to assure that the call is coming from either the strategies\n * management or the keeper.\n */\n modifier onlyKeepers() {\n TokenizedStrategy.requireKeeperOrManagement(msg.sender);\n _;\n }\n\n /**\n * @dev Use to assure that the call is coming from either the strategies\n * management or the emergency admin.\n */\n modifier onlyEmergencyAuthorized() {\n TokenizedStrategy.requireEmergencyAuthorized(msg.sender);\n _;\n }\n\n /**\n * @dev Require that the msg.sender is this address.\n */\n function _onlySelf() internal view {\n require(msg.sender == address(this), \"!self\");\n }\n\n /*//////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////*/\n\n /**\n * @dev This is the address of the TokenizedStrategy implementation\n * contract that will be used by all strategies to handle the\n * accounting, logic, storage etc.\n *\n * Any external calls to the that don't hit one of the functions\n * defined in this base or the strategy will end up being forwarded\n * through the fallback function, which will delegateCall this address.\n *\n * This address should be the same for every strategy, never be adjusted\n * and always be checked before any integration with the Strategy.\n */\n address public constant tokenizedStrategyAddress = 0xD377919FA87120584B21279a491F82D5265A139c;\n\n /*//////////////////////////////////////////////////////////////\n IMMUTABLES\n //////////////////////////////////////////////////////////////*/\n\n /**\n * @dev Underlying asset the Strategy is earning yield on.\n * Stored here for cheap retrievals within the strategy.\n */\n ERC20 internal immutable asset;\n\n /**\n * @dev This variable is set to address(this) during initialization of each strategy.\n *\n * This can be used to retrieve storage data within the strategy\n * contract as if it were a linked library.\n *\n * i.e. uint256 totalAssets = TokenizedStrategy.totalAssets()\n *\n * Using address(this) will mean any calls using this variable will lead\n * to a call to itself. Which will hit the fallback function and\n * delegateCall that to the actual TokenizedStrategy.\n */\n ITokenizedStrategy internal immutable TokenizedStrategy;\n\n /**\n * @notice Used to initialize the strategy on deployment.\n *\n * This will set the `TokenizedStrategy` variable for easy\n * internal view calls to the implementation. As well as\n * initializing the default storage variables based on the\n * parameters and using the deployer for the permissioned roles.\n *\n * @param _asset Address of the underlying asset.\n * @param _name Name the strategy will use.\n */\n constructor(address _asset, string memory _name) {\n asset = ERC20(_asset);\n\n // Set instance of the implementation for internal use.\n TokenizedStrategy = ITokenizedStrategy(address(this));\n\n // Initialize the strategy's storage variables.\n _delegateCall(\n abi.encodeCall(ITokenizedStrategy.initialize, (_asset, _name, msg.sender, msg.sender, msg.sender))\n );\n\n // Store the tokenizedStrategyAddress at the standard implementation\n // address storage slot so etherscan picks up the interface. This gets\n // stored on initialization and never updated.\n assembly {\n sstore(\n // keccak256('eip1967.proxy.implementation' - 1)\n 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc,\n tokenizedStrategyAddress\n )\n }\n }\n\n /*//////////////////////////////////////////////////////////////\n NEEDED TO BE OVERRIDDEN BY STRATEGIST\n //////////////////////////////////////////////////////////////*/\n\n /**\n * @dev Can deploy up to '_amount' of 'asset' in the yield source.\n *\n * This function is called at the end of a {deposit} or {mint}\n * call. Meaning that unless a whitelist is implemented it will\n * be entirely permissionless and thus can be sandwiched or otherwise\n * manipulated.\n *\n * @param _amount The amount of 'asset' that the strategy can attempt\n * to deposit in the yield source.\n */\n function _deployFunds(\n uint256 _amount\n ) internal virtual;\n\n /**\n * @dev Should attempt to free the '_amount' of 'asset'.\n *\n * NOTE: The amount of 'asset' that is already loose has already\n * been accounted for.\n *\n * This function is called during {withdraw} and {redeem} calls.\n * Meaning that unless a whitelist is implemented it will be\n * entirely permissionless and thus can be sandwiched or otherwise\n * manipulated.\n *\n * Should not rely on asset.balanceOf(address(this)) calls other than\n * for diff accounting purposes.\n *\n * Any difference between `_amount` and what is actually freed will be\n * counted as a loss and passed on to the withdrawer. This means\n * care should be taken in times of illiquidity. It may be better to revert\n * if withdraws are simply illiquid so not to realize incorrect losses.\n *\n * @param _amount, The amount of 'asset' to be freed.\n */\n function _freeFunds(\n uint256 _amount\n ) internal virtual;\n\n /**\n * @dev Internal function to harvest all rewards, redeploy any idle\n * funds and return an accurate accounting of all funds currently\n * held by the Strategy.\n *\n * This should do any needed harvesting, rewards selling, accrual,\n * redepositing etc. to get the most accurate view of current assets.\n *\n * NOTE: All applicable assets including loose assets should be\n * accounted for in this function.\n *\n * Care should be taken when relying on oracles or swap values rather\n * than actual amounts as all Strategy profit/loss accounting will\n * be done based on this returned value.\n *\n * This can still be called post a shutdown, a strategist can check\n * `TokenizedStrategy.isShutdown()` to decide if funds should be\n * redeployed or simply realize any profits/losses.\n *\n * @return _totalAssets A trusted and accurate account for the total\n * amount of 'asset' the strategy currently holds including idle funds.\n */\n function _harvestAndReport() internal virtual returns (uint256 _totalAssets);\n\n /*//////////////////////////////////////////////////////////////\n OPTIONAL TO OVERRIDE BY STRATEGIST\n //////////////////////////////////////////////////////////////*/\n\n /**\n * @dev Optional function for strategist to override that can\n * be called in between reports.\n *\n * If '_tend' is used tendTrigger() will also need to be overridden.\n *\n * This call can only be called by a permissioned role so may be\n * through protected relays.\n *\n * This can be used to harvest and compound rewards, deposit idle funds,\n * perform needed position maintenance or anything else that doesn't need\n * a full report for.\n *\n * EX: A strategy that can not deposit funds without getting\n * sandwiched can use the tend when a certain threshold\n * of idle to totalAssets has been reached.\n *\n * This will have no effect on PPS of the strategy till report() is called.\n *\n * @param _totalIdle The current amount of idle funds that are available to deploy.\n */\n function _tend(\n uint256 _totalIdle\n ) internal virtual {}\n\n /**\n * @dev Optional trigger to override if tend() will be used by the strategy.\n * This must be implemented if the strategy hopes to invoke _tend().\n *\n * @return . Should return true if tend() should be called by keeper or false if not.\n */\n function _tendTrigger() internal view virtual returns (bool) {\n return false;\n }\n\n /**\n * @notice Returns if tend() should be called by a keeper.\n *\n * @return . Should return true if tend() should be called by keeper or false if not.\n * @return . Calldata for the tend call.\n */\n function tendTrigger() external view virtual returns (bool, bytes memory) {\n return (\n // Return the status of the tend trigger.\n _tendTrigger(),\n // And the needed calldata either way.\n abi.encodeWithSelector(ITokenizedStrategy.tend.selector)\n );\n }\n\n /**\n * @notice Gets the max amount of `asset` that an address can deposit.\n * @dev Defaults to an unlimited amount for any address. But can\n * be overridden by strategists.\n *\n * This function will be called before any deposit or mints to enforce\n * any limits desired by the strategist. This can be used for either a\n * traditional deposit limit or for implementing a whitelist etc.\n *\n * EX:\n * if(isAllowed[_owner]) return super.availableDepositLimit(_owner);\n *\n * This does not need to take into account any conversion rates\n * from shares to assets. But should know that any non max uint256\n * amounts may be converted to shares. So it is recommended to keep\n * custom amounts low enough as not to cause overflow when multiplied\n * by `totalSupply`.\n *\n * @param . The address that is depositing into the strategy.\n * @return . The available amount the `_owner` can deposit in terms of `asset`\n */\n function availableDepositLimit(\n address /*_owner*/\n ) public view virtual returns (uint256) {\n return type(uint256).max;\n }\n\n /**\n * @notice Gets the max amount of `asset` that can be withdrawn.\n * @dev Defaults to an unlimited amount for any address. But can\n * be overridden by strategists.\n *\n * This function will be called before any withdraw or redeem to enforce\n * any limits desired by the strategist. This can be used for illiquid\n * or sandwichable strategies. It should never be lower than `totalIdle`.\n *\n * EX:\n * return TokenIzedStrategy.totalIdle();\n *\n * This does not need to take into account the `_owner`'s share balance\n * or conversion rates from shares to assets.\n *\n * @param . The address that is withdrawing from the strategy.\n * @return . The available amount that can be withdrawn in terms of `asset`\n */\n function availableWithdrawLimit(\n address /*_owner*/\n ) public view virtual returns (uint256) {\n return type(uint256).max;\n }\n\n /**\n * @dev Optional function for a strategist to override that will\n * allow management to manually withdraw deployed funds from the\n * yield source if a strategy is shutdown.\n *\n * This should attempt to free `_amount`, noting that `_amount` may\n * be more than is currently deployed.\n *\n * NOTE: This will not realize any profits or losses. A separate\n * {report} will be needed in order to record any profit/loss. If\n * a report may need to be called after a shutdown it is important\n * to check if the strategy is shutdown during {_harvestAndReport}\n * so that it does not simply re-deploy all funds that had been freed.\n *\n * EX:\n * if(freeAsset > 0 && !TokenizedStrategy.isShutdown()) {\n * depositFunds...\n * }\n *\n * @param _amount The amount of asset to attempt to free.\n */\n function _emergencyWithdraw(\n uint256 _amount\n ) internal virtual {}\n\n /*//////////////////////////////////////////////////////////////\n TokenizedStrategy HOOKS\n //////////////////////////////////////////////////////////////*/\n\n /**\n * @notice Can deploy up to '_amount' of 'asset' in yield source.\n * @dev Callback for the TokenizedStrategy to call during a {deposit}\n * or {mint} to tell the strategy it can deploy funds.\n *\n * Since this can only be called after a {deposit} or {mint}\n * delegateCall to the TokenizedStrategy msg.sender == address(this).\n *\n * Unless a whitelist is implemented this will be entirely permissionless\n * and thus can be sandwiched or otherwise manipulated.\n *\n * @param _amount The amount of 'asset' that the strategy can\n * attempt to deposit in the yield source.\n */\n function deployFunds(\n uint256 _amount\n ) external virtual onlySelf {\n _deployFunds(_amount);\n }\n\n /**\n * @notice Should attempt to free the '_amount' of 'asset'.\n * @dev Callback for the TokenizedStrategy to call during a withdraw\n * or redeem to free the needed funds to service the withdraw.\n *\n * This can only be called after a 'withdraw' or 'redeem' delegateCall\n * to the TokenizedStrategy so msg.sender == address(this).\n *\n * @param _amount The amount of 'asset' that the strategy should attempt to free up.\n */\n function freeFunds(\n uint256 _amount\n ) external virtual onlySelf {\n _freeFunds(_amount);\n }\n\n /**\n * @notice Returns the accurate amount of all funds currently\n * held by the Strategy.\n * @dev Callback for the TokenizedStrategy to call during a report to\n * get an accurate accounting of assets the strategy controls.\n *\n * This can only be called after a report() delegateCall to the\n * TokenizedStrategy so msg.sender == address(this).\n *\n * @return . A trusted and accurate account for the total amount\n * of 'asset' the strategy currently holds including idle funds.\n */\n function harvestAndReport() external virtual onlySelf returns (uint256) {\n return _harvestAndReport();\n }\n\n /**\n * @notice Will call the internal '_tend' when a keeper tends the strategy.\n * @dev Callback for the TokenizedStrategy to initiate a _tend call in the strategy.\n *\n * This can only be called after a tend() delegateCall to the TokenizedStrategy\n * so msg.sender == address(this).\n *\n * We name the function `tendThis` so that `tend` calls are forwarded to\n * the TokenizedStrategy.\n *\n * @param _totalIdle The amount of current idle funds that can be\n * deployed during the tend\n */\n function tendThis(\n uint256 _totalIdle\n ) external virtual onlySelf {\n _tend(_totalIdle);\n }\n\n /**\n * @notice Will call the internal '_emergencyWithdraw' function.\n * @dev Callback for the TokenizedStrategy during an emergency withdraw.\n *\n * This can only be called after a emergencyWithdraw() delegateCall to\n * the TokenizedStrategy so msg.sender == address(this).\n *\n * We name the function `shutdownWithdraw` so that `emergencyWithdraw`\n * calls are forwarded to the TokenizedStrategy.\n *\n * @param _amount The amount of asset to attempt to free.\n */\n function shutdownWithdraw(\n uint256 _amount\n ) external virtual onlySelf {\n _emergencyWithdraw(_amount);\n }\n\n /**\n * @dev Function used to delegate call the TokenizedStrategy with\n * certain `_calldata` and return any return values.\n *\n * This is used to setup the initial storage of the strategy, and\n * can be used by strategist to forward any other call to the\n * TokenizedStrategy implementation.\n *\n * @param _calldata The abi encoded calldata to use in delegatecall.\n * @return . The return value if the call was successful in bytes.\n */\n function _delegateCall(\n bytes memory _calldata\n ) internal returns (bytes memory) {\n // Delegate call the tokenized strategy with provided calldata.\n (bool success, bytes memory result) = tokenizedStrategyAddress.delegatecall(_calldata);\n\n // If the call reverted. Return the error.\n if (!success) {\n assembly {\n let ptr := mload(0x40)\n let size := returndatasize()\n returndatacopy(ptr, 0, size)\n revert(ptr, size)\n }\n }\n\n // Return the result.\n return result;\n }\n\n /**\n * @dev Execute a function on the TokenizedStrategy and return any value.\n *\n * This fallback function will be executed when any of the standard functions\n * defined in the TokenizedStrategy are called since they wont be defined in\n * this contract.\n *\n * It will delegatecall the TokenizedStrategy implementation with the exact\n * calldata and return any relevant values.\n *\n */\n fallback() external {\n // load our target address\n address _tokenizedStrategyAddress = tokenizedStrategyAddress;\n // Execute external function using delegatecall and return any value.\n assembly {\n // Copy function selector and any arguments.\n calldatacopy(0, 0, calldatasize())\n // Execute function delegatecall.\n let result := delegatecall(gas(), _tokenizedStrategyAddress, 0, calldatasize(), 0, 0)\n // Get any return value\n returndatacopy(0, 0, returndatasize())\n // Return any return value or error back to the caller\n switch result\n case 0 { revert(0, returndatasize()) }\n default { return(0, returndatasize()) }\n }\n }\n\n}\n"},{"file_path":"lib/tokenized-strategy/src/interfaces/ITokenizedStrategy.sol","source_code":"// SPDX-License-Identifier: AGPL-3.0\npragma solidity >=0.8.18;\n\nimport {ERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {IERC4626} from \"@openzeppelin/contracts/interfaces/IERC4626.sol\";\nimport {IERC20Permit} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\n\n// Interface that implements the 4626 standard and the implementation functions\ninterface ITokenizedStrategy is IERC4626, IERC20Permit {\n\n /*//////////////////////////////////////////////////////////////\n EVENTS\n //////////////////////////////////////////////////////////////*/\n\n event StrategyShutdown();\n\n event NewTokenizedStrategy(address indexed strategy, address indexed asset, string apiVersion);\n\n event Reported(uint256 profit, uint256 loss, uint256 protocolFees, uint256 performanceFees);\n\n event UpdatePerformanceFeeRecipient(address indexed newPerformanceFeeRecipient);\n\n event UpdateKeeper(address indexed newKeeper);\n\n event UpdatePerformanceFee(uint16 newPerformanceFee);\n\n event UpdateManagement(address indexed newManagement);\n\n event UpdateEmergencyAdmin(address indexed newEmergencyAdmin);\n\n event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime);\n\n event UpdatePendingManagement(address indexed newPendingManagement);\n\n /*//////////////////////////////////////////////////////////////\n INITIALIZATION\n //////////////////////////////////////////////////////////////*/\n\n function initialize(\n address _asset,\n string memory _name,\n address _management,\n address _performanceFeeRecipient,\n address _keeper\n ) external;\n\n /*//////////////////////////////////////////////////////////////\n NON-STANDARD 4626 OPTIONS\n //////////////////////////////////////////////////////////////*/\n\n function withdraw(uint256 assets, address receiver, address owner, uint256 maxLoss) external returns (uint256);\n\n function redeem(uint256 shares, address receiver, address owner, uint256 maxLoss) external returns (uint256);\n\n function maxWithdraw(address owner, uint256 /*maxLoss*/ ) external view returns (uint256);\n\n function maxRedeem(address owner, uint256 /*maxLoss*/ ) external view returns (uint256);\n\n /*//////////////////////////////////////////////////////////////\n MODIFIER HELPERS\n //////////////////////////////////////////////////////////////*/\n\n function requireManagement(\n address _sender\n ) external view;\n\n function requireKeeperOrManagement(\n address _sender\n ) external view;\n\n function requireEmergencyAuthorized(\n address _sender\n ) external view;\n\n /*//////////////////////////////////////////////////////////////\n KEEPERS FUNCTIONS\n //////////////////////////////////////////////////////////////*/\n\n function tend() external;\n\n function report() external returns (uint256 _profit, uint256 _loss);\n\n /*//////////////////////////////////////////////////////////////\n CONSTANTS\n //////////////////////////////////////////////////////////////*/\n\n function MAX_FEE() external view returns (uint16);\n\n function FACTORY() external view returns (address);\n\n /*//////////////////////////////////////////////////////////////\n GETTERS\n //////////////////////////////////////////////////////////////*/\n\n function apiVersion() external view returns (string memory);\n\n function pricePerShare() external view returns (uint256);\n\n function management() external view returns (address);\n\n function pendingManagement() external view returns (address);\n\n function keeper() external view returns (address);\n\n function emergencyAdmin() external view returns (address);\n\n function performanceFee() external view returns (uint16);\n\n function performanceFeeRecipient() external view returns (address);\n\n function fullProfitUnlockDate() external view returns (uint256);\n\n function profitUnlockingRate() external view returns (uint256);\n\n function profitMaxUnlockTime() external view returns (uint256);\n\n function lastReport() external view returns (uint256);\n\n function isShutdown() external view returns (bool);\n\n function unlockedShares() external view returns (uint256);\n\n /*//////////////////////////////////////////////////////////////\n SETTERS\n //////////////////////////////////////////////////////////////*/\n\n function setPendingManagement(\n address\n ) external;\n\n function acceptManagement() external;\n\n function setKeeper(\n address _keeper\n ) external;\n\n function setEmergencyAdmin(\n address _emergencyAdmin\n ) external;\n\n function setPerformanceFee(\n uint16 _performanceFee\n ) external;\n\n function setPerformanceFeeRecipient(\n address _performanceFeeRecipient\n ) external;\n\n function setProfitMaxUnlockTime(\n uint256 _profitMaxUnlockTime\n ) external;\n\n function setName(\n string calldata _newName\n ) external;\n\n function shutdownStrategy() external;\n\n function emergencyWithdraw(\n uint256 _amount\n ) external;\n\n}\n"},{"file_path":"lib/yearn-vaults-v3/contracts/interfaces/IVault.sol","source_code":"// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.8.18;\n\nimport {IERC4626} from \"@openzeppelin/contracts/interfaces/IERC4626.sol\";\n\ninterface IVault is IERC4626 {\n\n // STRATEGY EVENTS\n event StrategyChanged(address indexed strategy, uint256 change_type);\n event StrategyReported(\n address indexed strategy,\n uint256 gain,\n uint256 loss,\n uint256 current_debt,\n uint256 protocol_fees,\n uint256 total_fees,\n uint256 total_refunds\n );\n // DEBT MANAGEMENT EVENTS\n event DebtUpdated(address indexed strategy, uint256 current_debt, uint256 new_debt);\n // ROLE UPDATES\n event RoleSet(address indexed account, uint256 role);\n event UpdateFutureRoleManager(address indexed future_role_manager);\n event UpdateRoleManager(address indexed role_manager);\n\n event UpdateAccountant(address indexed accountant);\n event UpdateDefaultQueue(address[] new_default_queue);\n event UpdateUseDefaultQueue(bool use_default_queue);\n event UpdatedMaxDebtForStrategy(address indexed sender, address indexed strategy, uint256 new_debt);\n event UpdateAutoAllocate(bool auto_allocate);\n event UpdateDepositLimit(uint256 deposit_limit);\n event UpdateMinimumTotalIdle(uint256 minimum_total_idle);\n event UpdateProfitMaxUnlockTime(uint256 profit_max_unlock_time);\n event DebtPurchased(address indexed strategy, uint256 amount);\n event Shutdown();\n\n struct StrategyParams {\n uint256 activation;\n uint256 last_report;\n uint256 current_debt;\n uint256 max_debt;\n }\n\n function FACTORY() external view returns (uint256);\n\n function strategies(\n address\n ) external view returns (StrategyParams memory);\n\n function default_queue(\n uint256\n ) external view returns (address);\n\n function use_default_queue() external view returns (bool);\n\n function auto_allocate() external view returns (bool);\n\n function minimum_total_idle() external view returns (uint256);\n\n function deposit_limit() external view returns (uint256);\n\n function deposit_limit_module() external view returns (address);\n\n function withdraw_limit_module() external view returns (address);\n\n function accountant() external view returns (address);\n\n function roles(\n address\n ) external view returns (uint256);\n\n function role_manager() external view returns (address);\n\n function future_role_manager() external view returns (address);\n\n function isShutdown() external view returns (bool);\n\n function nonces(\n address\n ) external view returns (uint256);\n\n function initialize(address, string memory, string memory, address, uint256) external;\n\n function setName(\n string memory\n ) external;\n\n function setSymbol(\n string memory\n ) external;\n\n function set_accountant(\n address new_accountant\n ) external;\n\n function set_default_queue(\n address[] memory new_default_queue\n ) external;\n\n function set_use_default_queue(\n bool\n ) external;\n\n function set_auto_allocate(\n bool\n ) external;\n\n function set_deposit_limit(\n uint256 deposit_limit\n ) external;\n\n function set_deposit_limit(uint256 deposit_limit, bool should_override) external;\n\n function set_deposit_limit_module(\n address new_deposit_limit_module\n ) external;\n\n function set_deposit_limit_module(address new_deposit_limit_module, bool should_override) external;\n\n function set_withdraw_limit_module(\n address new_withdraw_limit_module\n ) external;\n\n function set_minimum_total_idle(\n uint256 minimum_total_idle\n ) external;\n\n function setProfitMaxUnlockTime(\n uint256 new_profit_max_unlock_time\n ) external;\n\n function set_role(address account, uint256 role) external;\n\n function add_role(address account, uint256 role) external;\n\n function remove_role(address account, uint256 role) external;\n\n function transfer_role_manager(\n address role_manager\n ) external;\n\n function accept_role_manager() external;\n\n function unlockedShares() external view returns (uint256);\n\n function pricePerShare() external view returns (uint256);\n\n function get_default_queue() external view returns (address[] memory);\n\n function process_report(\n address strategy\n ) external returns (uint256, uint256);\n\n function buy_debt(address strategy, uint256 amount) external;\n\n function add_strategy(\n address new_strategy\n ) external;\n\n function revoke_strategy(\n address strategy\n ) external;\n\n function force_revoke_strategy(\n address strategy\n ) external;\n\n function update_max_debt_for_strategy(address strategy, uint256 new_max_debt) external;\n\n function update_debt(address strategy, uint256 target_debt) external returns (uint256);\n\n function update_debt(address strategy, uint256 target_debt, uint256 max_loss) external returns (uint256);\n\n function shutdown_vault() external;\n\n function totalIdle() external view returns (uint256);\n\n function totalDebt() external view returns (uint256);\n\n function apiVersion() external view returns (string memory);\n\n function assess_share_of_unrealised_losses(\n address strategy,\n uint256 assets_needed\n ) external view returns (uint256);\n\n function profitMaxUnlockTime() external view returns (uint256);\n\n function fullProfitUnlockDate() external view returns (uint256);\n\n function profitUnlockingRate() external view returns (uint256);\n\n function lastProfitUpdate() external view returns (uint256);\n\n //// NON-STANDARD ERC-4626 FUNCTIONS \\\\\\\\\n\n function withdraw(uint256 assets, address receiver, address owner, uint256 max_loss) external returns (uint256);\n\n function withdraw(\n uint256 assets,\n address receiver,\n address owner,\n uint256 max_loss,\n address[] memory strategies\n ) external returns (uint256);\n\n function redeem(uint256 shares, address receiver, address owner, uint256 max_loss) external returns (uint256);\n\n function redeem(\n uint256 shares,\n address receiver,\n address owner,\n uint256 max_loss,\n address[] memory strategies\n ) external returns (uint256);\n\n function maxWithdraw(address owner, uint256 max_loss) external view returns (uint256);\n\n function maxWithdraw(\n address owner,\n uint256 max_loss,\n address[] memory strategies\n ) external view returns (uint256);\n\n function maxRedeem(address owner, uint256 max_loss) external view returns (uint256);\n\n function maxRedeem(address owner, uint256 max_loss, address[] memory strategies) external view returns (uint256);\n\n //// NON-STANDARD ERC-20 FUNCTIONS \\\\\\\\\n\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n\n function permit(\n address owner,\n address spender,\n uint256 amount,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) external returns (bool);\n\n}\n"},{"file_path":"src/interfaces/IAccountant.sol","source_code":"// SPDX-License-Identifier: AGPL-3.0\npragma solidity 0.8.23;\n\ninterface IAccountant {\n\n function distribute(\n address token\n ) external;\n\n}\n"}],"certified":false,"conflicting_implementations":null,"abi":[{"inputs":[{"internalType":"address","name":"_vault","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"ACCOUNTANT","outputs":[{"internalType":"contract IAccountant","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","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":"freeFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestAndReport","outputs":[{"internalType":"uint256","name":"_totalAssets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lossLimitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"profitLimitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"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"}],"is_changed_bytecode":false,"is_partially_verified":false,"constructor_args":"0x0000000000000000000000009f4330700a36b29952869fac9b33f45eedd8a3d80000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000c5374616b65642079424f4c440000000000000000000000000000000000000000"}