{ "address": "0xEE083E0F0f5dE2ff34662F1ef6f76d897d5047EF", "abi": [ { "inputs": [ { "internalType": "address", "name": "_router", "type": "address" }, { "internalType": "address", "name": "_masterChef", "type": "address" }, { "internalType": "address", "name": "_yieldVault", "type": "address" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "InvalidAddress", "type": "error" }, { "inputs": [], "name": "MigratorSet", "type": "error" }, { "inputs": [], "name": "TokenCreated", "type": "error" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "uint256", "name": "pid", "type": "uint256" }, { "indexed": true, "internalType": "address", "name": "token", "type": "address" } ], "name": "CreateFarmingLPToken", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "previousOwner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "OwnershipTransferred", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "migrator", "type": "address" } ], "name": "UpdateMigrator", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "vault", "type": "address" } ], "name": "UpdateVault", "type": "event" }, { "inputs": [ { "internalType": "uint256", "name": "pid", "type": "uint256" } ], "name": "createFarmingLPToken", "outputs": [ { "internalType": "address", "name": "token", "type": "address" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "name": "getFarmingLPToken", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "masterChef", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "migrator", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "owner", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "pid", "type": "uint256" } ], "name": "predictFarmingLPTokenAddress", "outputs": [ { "internalType": "address", "name": "token", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "renounceOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "router", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "transferOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "_migrator", "type": "address" } ], "name": "updateMigrator", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "vault", "type": "address" } ], "name": "updateYieldVault", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "yieldVault", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0xefb1bf72c4c656994938cd15ab9101b62f6df9341d0e12ed916c34efc1f4c052", "receipt": { "to": null, "from": "0x612ef87bfcd858687160294b0eFFACA0CBA342E2", "contractAddress": "0xEE083E0F0f5dE2ff34662F1ef6f76d897d5047EF", "transactionIndex": 167, "gasUsed": "3889237", "logsBloom": "0x00000000000000004000000000010000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000001000000000000000000000000000000000000020000000000000000000800000000000000000000000000000008400000000400000000000000000000000000000000000080000000000000000000000000000002000000000000000400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000020000000000000000800200000000000000000000000000000000000000000001000", "blockHash": "0xe1c8bba437c27b3b4ffa13722788c5011be311c000f55a72fda2fd7c8a0f19f5", "transactionHash": "0xefb1bf72c4c656994938cd15ab9101b62f6df9341d0e12ed916c34efc1f4c052", "logs": [ { "transactionIndex": 167, "blockNumber": 16343671, "transactionHash": "0xefb1bf72c4c656994938cd15ab9101b62f6df9341d0e12ed916c34efc1f4c052", "address": "0xEE083E0F0f5dE2ff34662F1ef6f76d897d5047EF", "topics": [ "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x000000000000000000000000612ef87bfcd858687160294b0effaca0cba342e2" ], "data": "0x", "logIndex": 459, "blockHash": "0xe1c8bba437c27b3b4ffa13722788c5011be311c000f55a72fda2fd7c8a0f19f5" }, { "transactionIndex": 167, "blockNumber": 16343671, "transactionHash": "0xefb1bf72c4c656994938cd15ab9101b62f6df9341d0e12ed916c34efc1f4c052", "address": "0x44D1C6b94B282c678c95B7f4B18de5A53EA4Fa9f", "topics": [ "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000001", "logIndex": 460, "blockHash": "0xe1c8bba437c27b3b4ffa13722788c5011be311c000f55a72fda2fd7c8a0f19f5" } ], "blockNumber": 16343671, "cumulativeGasUsed": "21268172", "status": 1, "byzantium": true }, "args": [ "0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F", "0xc2EdaD668740f1aA35E4D8f227fB8E17dcA888Cd", "0x3e55AC0E6724BBe8aB40a60771B5D60fC8e93404" ], "numDeployments": 1, "solcInputHash": "8c17aa148ad85bf7109c5d60e7cb8c68", "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_router\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_masterChef\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_yieldVault\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"InvalidAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MigratorSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TokenCreated\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"pid\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"CreateFarmingLPToken\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"migrator\",\"type\":\"address\"}],\"name\":\"UpdateMigrator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"UpdateVault\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"pid\",\"type\":\"uint256\"}],\"name\":\"createFarmingLPToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"getFarmingLPToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"masterChef\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"migrator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"pid\",\"type\":\"uint256\"}],\"name\":\"predictFarmingLPTokenAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"router\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_migrator\",\"type\":\"address\"}],\"name\":\"updateMigrator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"updateYieldVault\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"yieldVault\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/FarmingLPTokenFactory.sol\":\"FarmingLPTokenFactory\"},\"evmVersion\":\"london\",\"libraries\":{\":__CACHE_BREAKER__\":\"0x00000000d41867734bbee4c6863d9255b2b06ac1\"},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xa94b34880e3c1b0b931662cb1c09e5dfa6662f31cba80e07c5ee71cd135c9673\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.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 event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);\\n\\n event Withdraw(\\n address indexed sender,\\n address indexed receiver,\\n address indexed owner,\\n uint256 assets,\\n 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 \\u201cmanaged\\u201d 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 \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n * from.\\n */\\n function convertToShares(uint256 assets) 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 \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n * from.\\n */\\n function convertToAssets(uint256 shares) 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(address receiver) 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(uint256 assets) 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\\u2019s 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(address receiver) 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(uint256 shares) 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\\u2019s 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(address owner) 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(uint256 assets) 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(\\n uint256 assets,\\n address receiver,\\n address owner\\n ) 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(address owner) 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(uint256 shares) 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(\\n uint256 shares,\\n address receiver,\\n address owner\\n ) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd82776ed6975a5939668e068f995acb1394c2f60a12a9ef3f14cacb91b5a8fd4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Clones.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (proxy/Clones.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for\\n * deploying minimal proxy contracts, also known as \\\"clones\\\".\\n *\\n * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies\\n * > a minimal bytecode implementation that delegates all calls to a known, fixed address.\\n *\\n * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`\\n * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the\\n * deterministic method.\\n *\\n * _Available since v3.4._\\n */\\nlibrary Clones {\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create opcode, which should never revert.\\n */\\n function clone(address implementation) internal returns (address instance) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\\n // of the `implementation` address with the bytecode before the address.\\n mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\\n // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\\n mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\\n instance := create(0, 0x09, 0x37)\\n }\\n require(instance != address(0), \\\"ERC1167: create failed\\\");\\n }\\n\\n /**\\n * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.\\n *\\n * This function uses the create2 opcode and a `salt` to deterministically deploy\\n * the clone. Using the same `implementation` and `salt` multiple time will revert, since\\n * the clones cannot be deployed twice at the same address.\\n */\\n function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes\\n // of the `implementation` address with the bytecode before the address.\\n mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))\\n // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.\\n mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))\\n instance := create2(0, 0x09, 0x37, salt)\\n }\\n require(instance != address(0), \\\"ERC1167: create2 failed\\\");\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(\\n address implementation,\\n bytes32 salt,\\n address deployer\\n ) internal pure returns (address predicted) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(add(ptr, 0x38), deployer)\\n mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)\\n mstore(add(ptr, 0x14), implementation)\\n mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)\\n mstore(add(ptr, 0x58), salt)\\n mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))\\n predicted := keccak256(add(ptr, 0x43), 0x55)\\n }\\n }\\n\\n /**\\n * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.\\n */\\n function predictDeterministicAddress(address implementation, bytes32 salt)\\n internal\\n view\\n returns (address predicted)\\n {\\n return predictDeterministicAddress(implementation, salt, address(this));\\n }\\n}\\n\",\"keccak256\":\"0x888d64d221d52c31d015b76e50ca1af5ef8ff076550810b49cea6b01d8267a10\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/Address.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\\n * constructor.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: setting the version to 255 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n\\n /**\\n * @dev Internal function that returns the initialized version. Returns `_initialized`\\n */\\n function _getInitializedVersion() internal view returns (uint8) {\\n return _initialized;\\n }\\n\\n /**\\n * @dev Internal function that returns the initialized version. Returns `_initializing`\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _initializing;\\n }\\n}\\n\",\"keccak256\":\"0xcee5467d5d873fb75dae6f98c01a8d25dd609f9d0374c7d39217bd5f9539a2d6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/security/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuard {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n constructor() {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n _nonReentrantBefore();\\n _;\\n _nonReentrantAfter();\\n }\\n\\n function _nonReentrantBefore() private {\\n // On the first call to nonReentrant, _status will be _NOT_ENTERED\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n }\\n\\n function _nonReentrantAfter() private {\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\n }\\n}\\n\",\"keccak256\":\"0x190dd6f8d592b7e4e930feb7f4313aeb8e1c4ad3154c27ce1cf6a512fc30d8cc\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.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 * @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(address account) 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(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9750c6b834f7b43000631af5cc30001c5f547b3ceb3635488f140f60e897ea6b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// 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 * @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\",\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-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 */\\ninterface IERC20Permit {\\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 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(address owner) 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\",\"keccak256\":\"0xf41ca991f30855bf80ffd11e9347856a517b977f0a6c2d52e6421a99b7840329\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../IERC20.sol\\\";\\nimport \\\"../extensions/draft-IERC20Permit.sol\\\";\\nimport \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n function safeTransfer(\\n IERC20 token,\\n address to,\\n uint256 value\\n ) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\\n }\\n\\n function safeTransferFrom(\\n IERC20 token,\\n address from,\\n address to,\\n uint256 value\\n ) internal {\\n _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\\n }\\n\\n /**\\n * @dev Deprecated. This function has issues similar to the ones found in\\n * {IERC20-approve}, and its usage is discouraged.\\n *\\n * Whenever possible, use {safeIncreaseAllowance} and\\n * {safeDecreaseAllowance} instead.\\n */\\n function safeApprove(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n // safeApprove should only be called when setting an initial allowance,\\n // or when resetting it to zero. To increase and decrease it, use\\n // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\\n require(\\n (value == 0) || (token.allowance(address(this), spender) == 0),\\n \\\"SafeERC20: approve from non-zero to non-zero allowance\\\"\\n );\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\\n }\\n\\n function safeIncreaseAllowance(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n uint256 newAllowance = token.allowance(address(this), spender) + value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n\\n function safeDecreaseAllowance(\\n IERC20 token,\\n address spender,\\n uint256 value\\n ) internal {\\n unchecked {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n require(oldAllowance >= value, \\\"SafeERC20: decreased allowance below zero\\\");\\n uint256 newAllowance = oldAllowance - value;\\n _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\\n }\\n }\\n\\n function safePermit(\\n IERC20Permit token,\\n address owner,\\n address spender,\\n uint256 value,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal {\\n uint256 nonceBefore = token.nonces(owner);\\n token.permit(owner, spender, value, deadline, v, r, s);\\n uint256 nonceAfter = token.nonces(owner);\\n require(nonceAfter == nonceBefore + 1, \\\"SafeERC20: permit did not succeed\\\");\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data, \\\"SafeERC20: low-level call failed\\\");\\n if (returndata.length > 0) {\\n // Return data is optional\\n require(abi.decode(returndata, (bool)), \\\"SafeERC20: ERC20 operation did not succeed\\\");\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9b72f93be69ca894d8492c244259615c4a742afc8d63720dbc8bb81087d9b238\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\\n * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\\n *\\n * _Available since v4.8._\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n if (success) {\\n if (returndata.length == 0) {\\n // only check isContract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n }\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason or using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n _revert(returndata, errorMessage);\\n }\\n }\\n\\n function _revert(bytes memory returndata, string memory errorMessage) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xf96f969e24029d43d0df89e59d365f277021dac62b48e1c1e3ebe0acdd7f1ca1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (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 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\",\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./math/Math.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n uint8 private constant _ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\\n */\\n function toString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\\n */\\n function toHexString(uint256 value) internal pure returns (string memory) {\\n unchecked {\\n return toHexString(value, Math.log256(value) + 1);\\n }\\n }\\n\\n /**\\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\\n */\\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n bytes memory buffer = new bytes(2 * length + 2);\\n buffer[0] = \\\"0\\\";\\n buffer[1] = \\\"x\\\";\\n for (uint256 i = 2 * length + 1; i > 1; --i) {\\n buffer[i] = _SYMBOLS[value & 0xf];\\n value >>= 4;\\n }\\n require(value == 0, \\\"Strings: hex length insufficient\\\");\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\\n }\\n}\\n\",\"keccak256\":\"0xa4d1d62251f8574deb032a35fc948386a9b4de74b812d4f545a1ac120486b48a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../Strings.sol\\\";\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV // Deprecated in v4.8\\n }\\n\\n function _throwError(RecoverError error) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature` or error string. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\\n if (signature.length == 65) {\\n bytes32 r;\\n bytes32 s;\\n uint8 v;\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n /// @solidity memory-safe-assembly\\n assembly {\\n r := mload(add(signature, 0x20))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n return tryRecover(hash, v, r, s);\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address, RecoverError) {\\n bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\\n uint8 v = uint8((uint256(vs) >> 255) + 27);\\n return tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n \\u00f7 2 + 1, and for v in (302): v \\u2208 {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS);\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from `s`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", Strings.toString(s.length), s));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n }\\n}\\n\",\"keccak256\":\"0xda898fa084aa1ddfdb346e6a40459e00a59d87071cce7c315a46d648dd71d0ba\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n enum Rounding {\\n Down, // Toward negative infinity\\n Up, // Toward infinity\\n Zero // Toward zero\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\\n * with further edits by Uniswap Labs also under MIT license.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator\\n ) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod0 := mul(x, y)\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n require(denominator > prod1);\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\\n // See https://cs.stackexchange.com/q/138556/92363.\\n\\n // Does not overflow because the denominator cannot be zero at this stage in the function.\\n uint256 twos = denominator & (~denominator + 1);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\\n // in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(\\n uint256 x,\\n uint256 y,\\n uint256 denominator,\\n Rounding rounding\\n ) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10**64) {\\n value /= 10**64;\\n result += 64;\\n }\\n if (value >= 10**32) {\\n value /= 10**32;\\n result += 32;\\n }\\n if (value >= 10**16) {\\n value /= 10**16;\\n result += 16;\\n }\\n if (value >= 10**8) {\\n value /= 10**8;\\n result += 8;\\n }\\n if (value >= 10**4) {\\n value /= 10**4;\\n result += 4;\\n }\\n if (value >= 10**2) {\\n value /= 10**2;\\n result += 2;\\n }\\n if (value >= 10**1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256, rounded down, of a positive value.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xa1e8e83cd0087785df04ac79fb395d9f3684caeaf973d9e2c71caef723a3a5d6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n *\\n * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing\\n * all math on `uint256` and `int256` and then downcasting.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Returns the downcasted uint248 from uint256, reverting on\\n * overflow (when the input is greater than largest uint248).\\n *\\n * Counterpart to Solidity's `uint248` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 248 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint248(uint256 value) internal pure returns (uint248) {\\n require(value <= type(uint248).max, \\\"SafeCast: value doesn't fit in 248 bits\\\");\\n return uint248(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint240 from uint256, reverting on\\n * overflow (when the input is greater than largest uint240).\\n *\\n * Counterpart to Solidity's `uint240` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 240 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint240(uint256 value) internal pure returns (uint240) {\\n require(value <= type(uint240).max, \\\"SafeCast: value doesn't fit in 240 bits\\\");\\n return uint240(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint232 from uint256, reverting on\\n * overflow (when the input is greater than largest uint232).\\n *\\n * Counterpart to Solidity's `uint232` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 232 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint232(uint256 value) internal pure returns (uint232) {\\n require(value <= type(uint232).max, \\\"SafeCast: value doesn't fit in 232 bits\\\");\\n return uint232(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint224 from uint256, reverting on\\n * overflow (when the input is greater than largest uint224).\\n *\\n * Counterpart to Solidity's `uint224` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 224 bits\\n *\\n * _Available since v4.2._\\n */\\n function toUint224(uint256 value) internal pure returns (uint224) {\\n require(value <= type(uint224).max, \\\"SafeCast: value doesn't fit in 224 bits\\\");\\n return uint224(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint216 from uint256, reverting on\\n * overflow (when the input is greater than largest uint216).\\n *\\n * Counterpart to Solidity's `uint216` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 216 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint216(uint256 value) internal pure returns (uint216) {\\n require(value <= type(uint216).max, \\\"SafeCast: value doesn't fit in 216 bits\\\");\\n return uint216(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint208 from uint256, reverting on\\n * overflow (when the input is greater than largest uint208).\\n *\\n * Counterpart to Solidity's `uint208` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 208 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint208(uint256 value) internal pure returns (uint208) {\\n require(value <= type(uint208).max, \\\"SafeCast: value doesn't fit in 208 bits\\\");\\n return uint208(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint200 from uint256, reverting on\\n * overflow (when the input is greater than largest uint200).\\n *\\n * Counterpart to Solidity's `uint200` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 200 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint200(uint256 value) internal pure returns (uint200) {\\n require(value <= type(uint200).max, \\\"SafeCast: value doesn't fit in 200 bits\\\");\\n return uint200(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint192 from uint256, reverting on\\n * overflow (when the input is greater than largest uint192).\\n *\\n * Counterpart to Solidity's `uint192` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 192 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint192(uint256 value) internal pure returns (uint192) {\\n require(value <= type(uint192).max, \\\"SafeCast: value doesn't fit in 192 bits\\\");\\n return uint192(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint184 from uint256, reverting on\\n * overflow (when the input is greater than largest uint184).\\n *\\n * Counterpart to Solidity's `uint184` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 184 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint184(uint256 value) internal pure returns (uint184) {\\n require(value <= type(uint184).max, \\\"SafeCast: value doesn't fit in 184 bits\\\");\\n return uint184(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint176 from uint256, reverting on\\n * overflow (when the input is greater than largest uint176).\\n *\\n * Counterpart to Solidity's `uint176` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 176 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint176(uint256 value) internal pure returns (uint176) {\\n require(value <= type(uint176).max, \\\"SafeCast: value doesn't fit in 176 bits\\\");\\n return uint176(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint168 from uint256, reverting on\\n * overflow (when the input is greater than largest uint168).\\n *\\n * Counterpart to Solidity's `uint168` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 168 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint168(uint256 value) internal pure returns (uint168) {\\n require(value <= type(uint168).max, \\\"SafeCast: value doesn't fit in 168 bits\\\");\\n return uint168(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint160 from uint256, reverting on\\n * overflow (when the input is greater than largest uint160).\\n *\\n * Counterpart to Solidity's `uint160` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 160 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint160(uint256 value) internal pure returns (uint160) {\\n require(value <= type(uint160).max, \\\"SafeCast: value doesn't fit in 160 bits\\\");\\n return uint160(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint152 from uint256, reverting on\\n * overflow (when the input is greater than largest uint152).\\n *\\n * Counterpart to Solidity's `uint152` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 152 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint152(uint256 value) internal pure returns (uint152) {\\n require(value <= type(uint152).max, \\\"SafeCast: value doesn't fit in 152 bits\\\");\\n return uint152(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint144 from uint256, reverting on\\n * overflow (when the input is greater than largest uint144).\\n *\\n * Counterpart to Solidity's `uint144` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 144 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint144(uint256 value) internal pure returns (uint144) {\\n require(value <= type(uint144).max, \\\"SafeCast: value doesn't fit in 144 bits\\\");\\n return uint144(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint136 from uint256, reverting on\\n * overflow (when the input is greater than largest uint136).\\n *\\n * Counterpart to Solidity's `uint136` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 136 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint136(uint256 value) internal pure returns (uint136) {\\n require(value <= type(uint136).max, \\\"SafeCast: value doesn't fit in 136 bits\\\");\\n return uint136(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v2.5._\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n require(value <= type(uint128).max, \\\"SafeCast: value doesn't fit in 128 bits\\\");\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint120 from uint256, reverting on\\n * overflow (when the input is greater than largest uint120).\\n *\\n * Counterpart to Solidity's `uint120` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 120 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint120(uint256 value) internal pure returns (uint120) {\\n require(value <= type(uint120).max, \\\"SafeCast: value doesn't fit in 120 bits\\\");\\n return uint120(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint112 from uint256, reverting on\\n * overflow (when the input is greater than largest uint112).\\n *\\n * Counterpart to Solidity's `uint112` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 112 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint112(uint256 value) internal pure returns (uint112) {\\n require(value <= type(uint112).max, \\\"SafeCast: value doesn't fit in 112 bits\\\");\\n return uint112(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint104 from uint256, reverting on\\n * overflow (when the input is greater than largest uint104).\\n *\\n * Counterpart to Solidity's `uint104` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 104 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint104(uint256 value) internal pure returns (uint104) {\\n require(value <= type(uint104).max, \\\"SafeCast: value doesn't fit in 104 bits\\\");\\n return uint104(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint96 from uint256, reverting on\\n * overflow (when the input is greater than largest uint96).\\n *\\n * Counterpart to Solidity's `uint96` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 96 bits\\n *\\n * _Available since v4.2._\\n */\\n function toUint96(uint256 value) internal pure returns (uint96) {\\n require(value <= type(uint96).max, \\\"SafeCast: value doesn't fit in 96 bits\\\");\\n return uint96(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint88 from uint256, reverting on\\n * overflow (when the input is greater than largest uint88).\\n *\\n * Counterpart to Solidity's `uint88` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 88 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint88(uint256 value) internal pure returns (uint88) {\\n require(value <= type(uint88).max, \\\"SafeCast: value doesn't fit in 88 bits\\\");\\n return uint88(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint80 from uint256, reverting on\\n * overflow (when the input is greater than largest uint80).\\n *\\n * Counterpart to Solidity's `uint80` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 80 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint80(uint256 value) internal pure returns (uint80) {\\n require(value <= type(uint80).max, \\\"SafeCast: value doesn't fit in 80 bits\\\");\\n return uint80(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint72 from uint256, reverting on\\n * overflow (when the input is greater than largest uint72).\\n *\\n * Counterpart to Solidity's `uint72` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 72 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint72(uint256 value) internal pure returns (uint72) {\\n require(value <= type(uint72).max, \\\"SafeCast: value doesn't fit in 72 bits\\\");\\n return uint72(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v2.5._\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n require(value <= type(uint64).max, \\\"SafeCast: value doesn't fit in 64 bits\\\");\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint56 from uint256, reverting on\\n * overflow (when the input is greater than largest uint56).\\n *\\n * Counterpart to Solidity's `uint56` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 56 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint56(uint256 value) internal pure returns (uint56) {\\n require(value <= type(uint56).max, \\\"SafeCast: value doesn't fit in 56 bits\\\");\\n return uint56(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint48 from uint256, reverting on\\n * overflow (when the input is greater than largest uint48).\\n *\\n * Counterpart to Solidity's `uint48` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 48 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint48(uint256 value) internal pure returns (uint48) {\\n require(value <= type(uint48).max, \\\"SafeCast: value doesn't fit in 48 bits\\\");\\n return uint48(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint40 from uint256, reverting on\\n * overflow (when the input is greater than largest uint40).\\n *\\n * Counterpart to Solidity's `uint40` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 40 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint40(uint256 value) internal pure returns (uint40) {\\n require(value <= type(uint40).max, \\\"SafeCast: value doesn't fit in 40 bits\\\");\\n return uint40(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v2.5._\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n require(value <= type(uint32).max, \\\"SafeCast: value doesn't fit in 32 bits\\\");\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint24 from uint256, reverting on\\n * overflow (when the input is greater than largest uint24).\\n *\\n * Counterpart to Solidity's `uint24` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 24 bits\\n *\\n * _Available since v4.7._\\n */\\n function toUint24(uint256 value) internal pure returns (uint24) {\\n require(value <= type(uint24).max, \\\"SafeCast: value doesn't fit in 24 bits\\\");\\n return uint24(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v2.5._\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n require(value <= type(uint16).max, \\\"SafeCast: value doesn't fit in 16 bits\\\");\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits\\n *\\n * _Available since v2.5._\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n require(value <= type(uint8).max, \\\"SafeCast: value doesn't fit in 8 bits\\\");\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n *\\n * _Available since v3.0._\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n require(value >= 0, \\\"SafeCast: value must be positive\\\");\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int248 from int256, reverting on\\n * overflow (when the input is less than smallest int248 or\\n * greater than largest int248).\\n *\\n * Counterpart to Solidity's `int248` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 248 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n downcasted = int248(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 248 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int240 from int256, reverting on\\n * overflow (when the input is less than smallest int240 or\\n * greater than largest int240).\\n *\\n * Counterpart to Solidity's `int240` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 240 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n downcasted = int240(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 240 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int232 from int256, reverting on\\n * overflow (when the input is less than smallest int232 or\\n * greater than largest int232).\\n *\\n * Counterpart to Solidity's `int232` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 232 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n downcasted = int232(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 232 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int224 from int256, reverting on\\n * overflow (when the input is less than smallest int224 or\\n * greater than largest int224).\\n *\\n * Counterpart to Solidity's `int224` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 224 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n downcasted = int224(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 224 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int216 from int256, reverting on\\n * overflow (when the input is less than smallest int216 or\\n * greater than largest int216).\\n *\\n * Counterpart to Solidity's `int216` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 216 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n downcasted = int216(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 216 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int208 from int256, reverting on\\n * overflow (when the input is less than smallest int208 or\\n * greater than largest int208).\\n *\\n * Counterpart to Solidity's `int208` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 208 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n downcasted = int208(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 208 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int200 from int256, reverting on\\n * overflow (when the input is less than smallest int200 or\\n * greater than largest int200).\\n *\\n * Counterpart to Solidity's `int200` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 200 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n downcasted = int200(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 200 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int192 from int256, reverting on\\n * overflow (when the input is less than smallest int192 or\\n * greater than largest int192).\\n *\\n * Counterpart to Solidity's `int192` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 192 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n downcasted = int192(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 192 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int184 from int256, reverting on\\n * overflow (when the input is less than smallest int184 or\\n * greater than largest int184).\\n *\\n * Counterpart to Solidity's `int184` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 184 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n downcasted = int184(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 184 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int176 from int256, reverting on\\n * overflow (when the input is less than smallest int176 or\\n * greater than largest int176).\\n *\\n * Counterpart to Solidity's `int176` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 176 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n downcasted = int176(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 176 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int168 from int256, reverting on\\n * overflow (when the input is less than smallest int168 or\\n * greater than largest int168).\\n *\\n * Counterpart to Solidity's `int168` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 168 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n downcasted = int168(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 168 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int160 from int256, reverting on\\n * overflow (when the input is less than smallest int160 or\\n * greater than largest int160).\\n *\\n * Counterpart to Solidity's `int160` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 160 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n downcasted = int160(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 160 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int152 from int256, reverting on\\n * overflow (when the input is less than smallest int152 or\\n * greater than largest int152).\\n *\\n * Counterpart to Solidity's `int152` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 152 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n downcasted = int152(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 152 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int144 from int256, reverting on\\n * overflow (when the input is less than smallest int144 or\\n * greater than largest int144).\\n *\\n * Counterpart to Solidity's `int144` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 144 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n downcasted = int144(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 144 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int136 from int256, reverting on\\n * overflow (when the input is less than smallest int136 or\\n * greater than largest int136).\\n *\\n * Counterpart to Solidity's `int136` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 136 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n downcasted = int136(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 136 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n downcasted = int128(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 128 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int120 from int256, reverting on\\n * overflow (when the input is less than smallest int120 or\\n * greater than largest int120).\\n *\\n * Counterpart to Solidity's `int120` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 120 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n downcasted = int120(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 120 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int112 from int256, reverting on\\n * overflow (when the input is less than smallest int112 or\\n * greater than largest int112).\\n *\\n * Counterpart to Solidity's `int112` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 112 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n downcasted = int112(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 112 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int104 from int256, reverting on\\n * overflow (when the input is less than smallest int104 or\\n * greater than largest int104).\\n *\\n * Counterpart to Solidity's `int104` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 104 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n downcasted = int104(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 104 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int96 from int256, reverting on\\n * overflow (when the input is less than smallest int96 or\\n * greater than largest int96).\\n *\\n * Counterpart to Solidity's `int96` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 96 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n downcasted = int96(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 96 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int88 from int256, reverting on\\n * overflow (when the input is less than smallest int88 or\\n * greater than largest int88).\\n *\\n * Counterpart to Solidity's `int88` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 88 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n downcasted = int88(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 88 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int80 from int256, reverting on\\n * overflow (when the input is less than smallest int80 or\\n * greater than largest int80).\\n *\\n * Counterpart to Solidity's `int80` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 80 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n downcasted = int80(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 80 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int72 from int256, reverting on\\n * overflow (when the input is less than smallest int72 or\\n * greater than largest int72).\\n *\\n * Counterpart to Solidity's `int72` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 72 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n downcasted = int72(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 72 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n downcasted = int64(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 64 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int56 from int256, reverting on\\n * overflow (when the input is less than smallest int56 or\\n * greater than largest int56).\\n *\\n * Counterpart to Solidity's `int56` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 56 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n downcasted = int56(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 56 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int48 from int256, reverting on\\n * overflow (when the input is less than smallest int48 or\\n * greater than largest int48).\\n *\\n * Counterpart to Solidity's `int48` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 48 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n downcasted = int48(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 48 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int40 from int256, reverting on\\n * overflow (when the input is less than smallest int40 or\\n * greater than largest int40).\\n *\\n * Counterpart to Solidity's `int40` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 40 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n downcasted = int40(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 40 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n downcasted = int32(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 32 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int24 from int256, reverting on\\n * overflow (when the input is less than smallest int24 or\\n * greater than largest int24).\\n *\\n * Counterpart to Solidity's `int24` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 24 bits\\n *\\n * _Available since v4.7._\\n */\\n function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n downcasted = int24(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 24 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n downcasted = int16(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 16 bits\\\");\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits\\n *\\n * _Available since v3.1._\\n */\\n function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n downcasted = int8(value);\\n require(downcasted == value, \\\"SafeCast: value doesn't fit in 8 bits\\\");\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n *\\n * _Available since v3.0._\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n require(value <= uint256(type(int256).max), \\\"SafeCast: value doesn't fit in an int256\\\");\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0x52a8cfb0f5239d11b457dcdd1b326992ef672714ca8da71a157255bddd13f3ad\",\"license\":\"MIT\"},\"@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Pair.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface IUniswapV2Pair {\\n event Approval(address indexed owner, address indexed spender, uint value);\\n event Transfer(address indexed from, address indexed to, uint value);\\n\\n function name() external pure returns (string memory);\\n function symbol() external pure returns (string memory);\\n function decimals() external pure returns (uint8);\\n function totalSupply() external view returns (uint);\\n function balanceOf(address owner) external view returns (uint);\\n function allowance(address owner, address spender) external view returns (uint);\\n\\n function approve(address spender, uint value) external returns (bool);\\n function transfer(address to, uint value) external returns (bool);\\n function transferFrom(address from, address to, uint value) external returns (bool);\\n\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n function PERMIT_TYPEHASH() external pure returns (bytes32);\\n function nonces(address owner) external view returns (uint);\\n\\n function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;\\n\\n event Mint(address indexed sender, uint amount0, uint amount1);\\n event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);\\n event Swap(\\n address indexed sender,\\n uint amount0In,\\n uint amount1In,\\n uint amount0Out,\\n uint amount1Out,\\n address indexed to\\n );\\n event Sync(uint112 reserve0, uint112 reserve1);\\n\\n function MINIMUM_LIQUIDITY() external pure returns (uint);\\n function factory() external view returns (address);\\n function token0() external view returns (address);\\n function token1() external view returns (address);\\n function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);\\n function price0CumulativeLast() external view returns (uint);\\n function price1CumulativeLast() external view returns (uint);\\n function kLast() external view returns (uint);\\n\\n function mint(address to) external returns (uint liquidity);\\n function burn(address to) external returns (uint amount0, uint amount1);\\n function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;\\n function skim(address to) external;\\n function sync() external;\\n\\n function initialize(address, address) external;\\n}\",\"keccak256\":\"0x08f9a63b34855eec941be8d36a04424f1a1725a2c030373fcef3afeb480ca385\",\"license\":\"GPL-3.0\"},\"@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Router01.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.6.2;\\n\\ninterface IUniswapV2Router01 {\\n function factory() external pure returns (address);\\n function WETH() external pure returns (address);\\n\\n function addLiquidity(\\n address tokenA,\\n address tokenB,\\n uint amountADesired,\\n uint amountBDesired,\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline\\n ) external returns (uint amountA, uint amountB, uint liquidity);\\n function addLiquidityETH(\\n address token,\\n uint amountTokenDesired,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline\\n ) external payable returns (uint amountToken, uint amountETH, uint liquidity);\\n function removeLiquidity(\\n address tokenA,\\n address tokenB,\\n uint liquidity,\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline\\n ) external returns (uint amountA, uint amountB);\\n function removeLiquidityETH(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline\\n ) external returns (uint amountToken, uint amountETH);\\n function removeLiquidityWithPermit(\\n address tokenA,\\n address tokenB,\\n uint liquidity,\\n uint amountAMin,\\n uint amountBMin,\\n address to,\\n uint deadline,\\n bool approveMax, uint8 v, bytes32 r, bytes32 s\\n ) external returns (uint amountA, uint amountB);\\n function removeLiquidityETHWithPermit(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline,\\n bool approveMax, uint8 v, bytes32 r, bytes32 s\\n ) external returns (uint amountToken, uint amountETH);\\n function swapExactTokensForTokens(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ) external returns (uint[] memory amounts);\\n function swapTokensForExactTokens(\\n uint amountOut,\\n uint amountInMax,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ) external returns (uint[] memory amounts);\\n function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)\\n external\\n payable\\n returns (uint[] memory amounts);\\n function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)\\n external\\n returns (uint[] memory amounts);\\n function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)\\n external\\n returns (uint[] memory amounts);\\n function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)\\n external\\n payable\\n returns (uint[] memory amounts);\\n\\n function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);\\n function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);\\n function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);\\n function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);\\n function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);\\n}\",\"keccak256\":\"0x12091adc186fe351c639dc62aa0b691f78c7bea054c27bbb4b58acd02e1b2ce7\",\"license\":\"GPL-3.0\"},\"@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Router02.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.6.2;\\n\\nimport './IUniswapV2Router01.sol';\\n\\ninterface IUniswapV2Router02 is IUniswapV2Router01 {\\n function removeLiquidityETHSupportingFeeOnTransferTokens(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline\\n ) external returns (uint amountETH);\\n function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(\\n address token,\\n uint liquidity,\\n uint amountTokenMin,\\n uint amountETHMin,\\n address to,\\n uint deadline,\\n bool approveMax, uint8 v, bytes32 r, bytes32 s\\n ) external returns (uint amountETH);\\n\\n function swapExactTokensForTokensSupportingFeeOnTransferTokens(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ) external;\\n function swapExactETHForTokensSupportingFeeOnTransferTokens(\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ) external payable;\\n function swapExactTokensForETHSupportingFeeOnTransferTokens(\\n uint amountIn,\\n uint amountOutMin,\\n address[] calldata path,\\n address to,\\n uint deadline\\n ) external;\\n}\",\"keccak256\":\"0x7e588378c1076243506b8164132e0dcccd468f31edb933a88ddb8d6c4063ab30\",\"license\":\"GPL-3.0\"},\"contracts/FarmingLPToken.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/interfaces/IERC4626.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport \\\"@openzeppelin/contracts/security/ReentrancyGuard.sol\\\";\\nimport \\\"@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Pair.sol\\\";\\nimport \\\"./interfaces/IFarmingLPToken.sol\\\";\\nimport \\\"./interfaces/IFarmingLPTokenFactory.sol\\\";\\nimport \\\"./interfaces/IFarmingLPTokenMigrator.sol\\\";\\nimport \\\"./interfaces/IMasterChef.sol\\\";\\nimport \\\"./libraries/UniswapV2Utils.sol\\\";\\nimport \\\"./base/BaseERC20.sol\\\";\\n\\ncontract FarmingLPToken is BaseERC20, ReentrancyGuard, IFarmingLPToken {\\n using SafeERC20 for IERC20;\\n using SafeCast for uint256;\\n using SafeCast for int256;\\n\\n uint128 internal constant POINTS_MULTIPLIER = type(uint128).max;\\n\\n address public override factory;\\n address public override router;\\n address public override masterChef;\\n uint256 public override pid;\\n address public override sushi;\\n address public override lpToken;\\n address public override token0;\\n address public override token1;\\n\\n uint256 public override withdrawableTotalLPs;\\n uint256 internal _pointsPerShare;\\n mapping(address => int256) internal _pointsCorrection;\\n mapping(address => uint256) internal _withdrawnVaultBalanceOf;\\n\\n function initialize(\\n address _router,\\n address _masterChef,\\n uint256 _pid\\n ) external override initializer {\\n if (_router == address(0)) return;\\n\\n factory = msg.sender;\\n (address _lpToken, , , ) = IMasterChef(_masterChef).poolInfo(_pid);\\n address _token0 = IUniswapV2Pair(_lpToken).token0();\\n address _token1 = IUniswapV2Pair(_lpToken).token1();\\n router = _router;\\n masterChef = _masterChef;\\n pid = _pid;\\n sushi = IMasterChef(_masterChef).sushi();\\n lpToken = _lpToken;\\n token0 = _token0;\\n token1 = _token1;\\n\\n BaseERC20_initialize(\\n string.concat(\\n \\\"Farming LP Token (\\\",\\n IERC20Metadata(_token0).name(),\\n \\\"-\\\",\\n IERC20Metadata(_token1).name(),\\n \\\")\\\"\\n ),\\n string.concat(\\\"fLP:\\\", IERC20Metadata(_token0).symbol(), \\\"-\\\", IERC20Metadata(_token1).symbol()),\\n \\\"1\\\"\\n );\\n approveMax();\\n }\\n\\n function withdrawableLPsOf(address account) external view override returns (uint256) {\\n uint256 total = totalShares();\\n if (total == 0) return 0;\\n return (sharesOf(account) * withdrawableTotalLPs) / total;\\n }\\n\\n /**\\n * @return Sum of (shares in SUSHI) + (withdrawable total SUSHI)\\n */\\n function totalSupply() public view override(BaseERC20, IERC20) returns (uint256) {\\n return totalShares() + withdrawableTotalYield();\\n }\\n\\n /**\\n * @return Sum of (shares in SUSHI by depositd account) + (SUSHI withdrawable by account)\\n */\\n function balanceOf(address account) public view override(BaseERC20, IERC20) returns (uint256) {\\n return sharesOf(account) + withdrawableYieldOf(account);\\n }\\n\\n /**\\n * @return total shares in SUSHI currently being depositd\\n */\\n function totalShares() public view override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @return shares in SUSHI currently being depositd by account\\n */\\n function sharesOf(address account) public view override returns (uint256) {\\n return _balanceOf[account];\\n }\\n\\n /**\\n * @dev Returns the total amount of SUSHI if every holder wants to withdraw at once\\n * @return A uint256 representing the total SUSHI\\n */\\n function withdrawableTotalYield() public view override returns (uint256) {\\n address yieldVault = IFarmingLPTokenFactory(factory).yieldVault();\\n uint256 pendingSushi = IMasterChef(masterChef).pendingSushi(pid, address(this));\\n return pendingSushi + IERC4626(yieldVault).maxWithdraw(address(this));\\n }\\n\\n /**\\n * @dev Returns the amount of SUSHI a given address is able to withdraw.\\n * @param account Address of a reward recipient\\n * @return A uint256 representing the SUSHI `account` can withdraw\\n */\\n function withdrawableYieldOf(address account) public view override returns (uint256) {\\n address yieldVault = IFarmingLPTokenFactory(factory).yieldVault();\\n return IERC4626(yieldVault).convertToAssets((_withdrawableVaultBalanceOf(account, true)));\\n }\\n\\n /**\\n * @dev Vault balance is used to record reward debt for account.\\n * @param account Address of a reward recipient\\n * @param preview if true, it adds the amount of MasterChef.pendingSushi()\\n * @return A uint256 representing the SUSHI `account` can withdraw\\n */\\n function _withdrawableVaultBalanceOf(address account, bool preview) internal view returns (uint256) {\\n return _cumulativeVaultBalanceOf(account, preview) - _withdrawnVaultBalanceOf[account];\\n }\\n\\n /**\\n * @notice View the amount of vault balance that an address has earned in total.\\n * @dev cumulativeVaultBalanceOf(account) = withdrawableVaultBalanceOf(account) + withdrawnVaultBalanceOf(account)\\n * = (pointsPerShare * sharesOf(account) + pointsCorrection[account]) / POINTS_MULTIPLIER\\n * @param account The address of a token holder.\\n * @param preview if true, it adds the amount of MasterChef.pendingSushi()\\n * @return The amount of SUSHI that `account` has earned in total.\\n */\\n function _cumulativeVaultBalanceOf(address account, bool preview) internal view returns (uint256) {\\n uint256 pointsPerShare = _pointsPerShare;\\n if (preview) {\\n uint256 total = totalShares();\\n if (total > 0) {\\n address yieldVault = IFarmingLPTokenFactory(factory).yieldVault();\\n uint256 pendingSushi = IMasterChef(masterChef).pendingSushi(pid, address(this));\\n pointsPerShare += (IERC4626(yieldVault).previewDeposit(pendingSushi) * POINTS_MULTIPLIER) / total;\\n }\\n }\\n return\\n ((pointsPerShare * sharesOf(account)).toInt256() + _pointsCorrection[account]).toUint256() /\\n POINTS_MULTIPLIER;\\n }\\n\\n function approveMax() public override {\\n IERC20(lpToken).approve(masterChef, type(uint256).max);\\n IERC20(sushi).approve(IFarmingLPTokenFactory(factory).yieldVault(), type(uint256).max);\\n IERC20(sushi).approve(router, type(uint256).max);\\n IERC20(token0).approve(router, type(uint256).max);\\n IERC20(token1).approve(router, type(uint256).max);\\n }\\n\\n /**\\n * @dev amount of sushi that LPs converted to is added to sharesOf(account) and aLP is minted\\n * user signature is needed for IUniswapV2Pair.permit()\\n */\\n function depositSigned(\\n uint256 amountLP,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountMin,\\n address beneficiary,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external override nonReentrant {\\n IUniswapV2Pair(lpToken).permit(msg.sender, address(this), amountLP, deadline, v, r, s);\\n _deposit(amountLP, path0, path1, amountMin, beneficiary);\\n }\\n\\n /**\\n * @dev amount of sushi that LPs converted to is added to sharesOf(account) and aLP is minted\\n */\\n function deposit(\\n uint256 amountLP,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountMin,\\n address beneficiary,\\n uint256 deadline\\n ) external override nonReentrant {\\n if (block.timestamp > deadline) revert Expired();\\n _deposit(amountLP, path0, path1, amountMin, beneficiary);\\n }\\n\\n function _deposit(\\n uint256 amountLP,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountMin,\\n address beneficiary\\n ) internal {\\n if (path0[0] != token0 || path0[path0.length - 1] != sushi) revert InvalidPath();\\n if (path1[0] != token1 || path1[path1.length - 1] != sushi) revert InvalidPath();\\n\\n IERC20(lpToken).safeTransferFrom(msg.sender, address(this), amountLP);\\n\\n uint256 total = IUniswapV2Pair(lpToken).totalSupply();\\n (uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(lpToken).getReserves();\\n uint256 amount = UniswapV2Utils.quote(router, (reserve0 * amountLP) / total, path0) +\\n UniswapV2Utils.quote(router, (reserve1 * amountLP) / total, path1);\\n\\n if (amount < amountMin) revert InsufficientAmount();\\n\\n IMasterChef(masterChef).deposit(pid, amountLP);\\n _depositSushi();\\n\\n _mint(beneficiary, amount);\\n withdrawableTotalLPs += amountLP;\\n\\n emit Deposit(amount, amountLP, beneficiary);\\n }\\n\\n /**\\n * @dev amount is added to sharesOf(account) and same amount of aLP is minted\\n * provided SUSHI is swapped then added as liquidity which results in LP tokens depositd\\n */\\n function depositWithSushi(\\n uint256 amount,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountLPMin,\\n address beneficiary,\\n uint256 deadline\\n ) external override {\\n if (path0[0] != sushi || path0[path0.length - 1] != token0) revert InvalidPath();\\n if (path1[0] != sushi || path1[path1.length - 1] != token1) revert InvalidPath();\\n\\n IERC20(sushi).safeTransferFrom(msg.sender, address(this), amount);\\n uint256 amountLP = UniswapV2Utils.addLiquidityWithSingleToken(router, amount, path0, path1, deadline);\\n if (amountLP < amountLPMin) revert InsufficientAmount();\\n\\n IMasterChef(masterChef).deposit(pid, amountLP);\\n _depositSushi();\\n\\n _mint(beneficiary, amount);\\n withdrawableTotalLPs += amountLP;\\n\\n emit Deposit(amount, amountLP, beneficiary);\\n }\\n\\n /**\\n * @dev when unstaking, the user's share of LP tokens are returned and pro-rata SUSHI yield is return as well\\n */\\n function withdraw(uint256 shares, address beneficiary) external override nonReentrant {\\n uint256 amountLP = (shares * withdrawableTotalLPs) / totalShares();\\n IMasterChef(masterChef).withdraw(pid, amountLP);\\n\\n _claimSushi(shares, beneficiary);\\n\\n IERC20(lpToken).safeTransfer(beneficiary, amountLP);\\n\\n _burn(msg.sender, shares);\\n withdrawableTotalLPs -= amountLP;\\n\\n emit Withdraw(shares, amountLP, beneficiary);\\n }\\n\\n function _claimSushi(uint256 shares, address beneficiary) internal {\\n _depositSushi();\\n\\n uint256 sharesMax = sharesOf(msg.sender);\\n if (shares > sharesMax) revert InsufficientAmount();\\n\\n address yieldVault = IFarmingLPTokenFactory(factory).yieldVault();\\n uint256 withdrawable = _withdrawableVaultBalanceOf(msg.sender, false);\\n if (withdrawable == 0) revert InsufficientYield();\\n\\n uint256 yieldShares = (withdrawable * shares) / sharesMax;\\n _withdrawnVaultBalanceOf[msg.sender] += yieldShares;\\n\\n uint256 yield = IERC4626(yieldVault).redeem(yieldShares, beneficiary, address(this));\\n\\n emit ClaimSushi(shares, yield, beneficiary);\\n }\\n\\n /**\\n * @dev withdraw without caring about rewards. EMERGENCY ONLY\\n */\\n function emergencyWithdraw(address beneficiary) external override nonReentrant {\\n uint256 shares = sharesOf(msg.sender);\\n uint256 amountLP = (shares * withdrawableTotalLPs) / totalShares();\\n IMasterChef(masterChef).withdraw(pid, amountLP);\\n\\n IERC20(lpToken).safeTransfer(beneficiary, amountLP);\\n\\n _burn(msg.sender, shares);\\n withdrawableTotalLPs -= amountLP;\\n\\n emit EmergencyWithdraw(shares, amountLP, beneficiary);\\n }\\n\\n /**\\n * @dev migrate to a new version of fLP\\n */\\n function migrate(address beneficiary, bytes calldata params) external nonReentrant {\\n address migrator = IFarmingLPTokenFactory(factory).migrator();\\n if (migrator == address(0)) revert NoMigratorSet();\\n\\n uint256 shares = sharesOf(msg.sender);\\n uint256 amountLP = (shares * withdrawableTotalLPs) / totalShares();\\n IMasterChef(masterChef).withdraw(pid, amountLP);\\n\\n _claimSushi(shares, beneficiary);\\n\\n _burn(msg.sender, shares);\\n withdrawableTotalLPs -= amountLP;\\n\\n address _lpToken = lpToken;\\n IERC20(_lpToken).approve(migrator, amountLP);\\n IFarmingLPTokenMigrator(migrator).onMigrate(msg.sender, pid, _lpToken, shares, amountLP, beneficiary, params);\\n\\n emit Migrate(shares, amountLP, beneficiary);\\n }\\n\\n /**\\n * @dev migrate to a new version of fLP without caring about rewards. EMERGENCY ONLY\\n */\\n function emergencyMigrate(address beneficiary, bytes calldata params) external nonReentrant {\\n address migrator = IFarmingLPTokenFactory(factory).migrator();\\n if (migrator == address(0)) revert NoMigratorSet();\\n\\n uint256 shares = sharesOf(msg.sender);\\n uint256 amountLP = (shares * withdrawableTotalLPs) / totalShares();\\n IMasterChef(masterChef).withdraw(pid, amountLP);\\n\\n _burn(msg.sender, shares);\\n withdrawableTotalLPs -= amountLP;\\n\\n address _lpToken = lpToken;\\n IERC20(_lpToken).approve(migrator, amountLP);\\n IFarmingLPTokenMigrator(migrator).onMigrate(msg.sender, pid, _lpToken, shares, amountLP, beneficiary, params);\\n\\n emit EmergencyMigrate(shares, amountLP, beneficiary);\\n }\\n\\n /**\\n * @dev withdraws pending SUSHI from MasterChef and add it to the balance\\n */\\n function checkpoint() external override nonReentrant {\\n uint256 balance = IERC20(lpToken).balanceOf(address(this));\\n if (balance > withdrawableTotalLPs) {\\n withdrawableTotalLPs = balance;\\n }\\n\\n IMasterChef(masterChef).deposit(pid, 0);\\n _depositSushi();\\n }\\n\\n function _depositSushi() internal {\\n uint256 balance = IERC20(sushi).balanceOf(address(this));\\n if (balance > 0) {\\n address yieldVault = IFarmingLPTokenFactory(factory).yieldVault();\\n uint256 yieldBalance = IERC4626(yieldVault).deposit(balance, address(this));\\n\\n uint256 total = totalShares();\\n if (total > 0) {\\n _pointsPerShare += (yieldBalance * POINTS_MULTIPLIER) / total;\\n }\\n }\\n }\\n\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal override returns (uint256 balanceOfFrom, uint256 balanceOfTo) {\\n uint256 balance = balanceOf(from);\\n uint256 shares = balance == 0 ? 0 : (amount * sharesOf(from)) / balance;\\n\\n (balanceOfFrom, balanceOfTo) = super._transfer(from, to, shares);\\n\\n int256 _magCorrection = (_pointsPerShare * shares).toInt256();\\n _pointsCorrection[from] += _magCorrection;\\n _pointsCorrection[to] += _magCorrection;\\n }\\n\\n function _mint(address account, uint256 shares) internal override {\\n super._mint(account, shares);\\n\\n _correctPoints(account, -int256(shares));\\n }\\n\\n function _burn(address account, uint256 shares) internal override {\\n super._burn(account, shares);\\n\\n _correctPoints(account, int256(shares));\\n }\\n\\n function _correctPoints(address account, int256 amount) internal {\\n _pointsCorrection[account] += amount * int256(_pointsPerShare);\\n }\\n}\\n\",\"keccak256\":\"0xd23a9237a3b569e92e6e31eac32e2259e8f74e055d0378b71f7beb70d191ea19\",\"license\":\"BUSL-1.1\"},\"contracts/FarmingLPTokenFactory.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/proxy/Clones.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"./interfaces/IFarmingLPTokenFactory.sol\\\";\\nimport \\\"./FarmingLPToken.sol\\\";\\n\\ncontract FarmingLPTokenFactory is Ownable, IFarmingLPTokenFactory {\\n address public immutable override router;\\n address public immutable override masterChef;\\n address internal immutable _implementation;\\n\\n address public override yieldVault;\\n address public override migrator;\\n mapping(uint256 => address) public override getFarmingLPToken;\\n\\n constructor(\\n address _router,\\n address _masterChef,\\n address _yieldVault\\n ) {\\n router = _router;\\n masterChef = _masterChef;\\n yieldVault = _yieldVault;\\n FarmingLPToken token = new FarmingLPToken();\\n token.initialize(address(0), address(0), 0);\\n _implementation = address(token);\\n }\\n\\n function predictFarmingLPTokenAddress(uint256 pid) external view override returns (address token) {\\n token = Clones.predictDeterministicAddress(_implementation, bytes32(pid));\\n }\\n\\n function updateYieldVault(address vault) external override onlyOwner {\\n if (vault == address(0)) revert InvalidAddress();\\n yieldVault = vault;\\n\\n emit UpdateVault(vault);\\n }\\n\\n function updateMigrator(address _migrator) external override onlyOwner {\\n if (_migrator != address(0)) revert MigratorSet();\\n migrator = _migrator;\\n\\n emit UpdateMigrator(_migrator);\\n }\\n\\n function createFarmingLPToken(uint256 pid) external override returns (address token) {\\n if (getFarmingLPToken[pid] != address(0)) revert TokenCreated();\\n\\n token = Clones.cloneDeterministic(_implementation, bytes32(pid));\\n FarmingLPToken(token).initialize(router, masterChef, pid);\\n\\n getFarmingLPToken[pid] = token;\\n\\n emit CreateFarmingLPToken(pid, token);\\n }\\n}\\n\",\"keccak256\":\"0x8ee93f6e49956151f3eede15a064521df20737d2de9eebd2da003cc7770afc11\",\"license\":\"BUSL-1.1\"},\"contracts/base/BaseERC20.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\\\";\\nimport \\\"@openzeppelin/contracts/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nabstract contract BaseERC20 is Initializable, IERC20Metadata {\\n error Expired();\\n error InvalidSignature();\\n error InvalidAccount();\\n error InvalidSender();\\n error InvalidReceiver();\\n error InvalidOwner();\\n error InvalidSpender();\\n error NotEnoughBalance();\\n\\n uint8 public constant override decimals = 18;\\n bytes32 private _CACHED_DOMAIN_SEPARATOR;\\n uint256 private _CACHED_CHAIN_ID;\\n address private _CACHED_THIS;\\n\\n bytes32 private _HASHED_NAME;\\n bytes32 private _HASHED_VERSION;\\n bytes32 private _TYPE_HASH;\\n\\n string public override name;\\n string public override symbol;\\n\\n uint256 internal _totalSupply;\\n mapping(address => uint256) internal _balanceOf;\\n mapping(address => mapping(address => uint256)) internal _allowance;\\n mapping(address => uint256) public nonces;\\n\\n bytes32 private constant _PERMIT_TYPEHASH =\\n keccak256(\\\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\");\\n\\n function BaseERC20_initialize(\\n string memory _name,\\n string memory _symbol,\\n string memory _version\\n ) internal onlyInitializing {\\n name = _name;\\n symbol = _symbol;\\n\\n bytes32 hashedName = keccak256(bytes(_name));\\n bytes32 hashedVersion = keccak256(bytes(_version));\\n bytes32 typeHash = keccak256(\\n \\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\"\\n );\\n _HASHED_NAME = hashedName;\\n _HASHED_VERSION = hashedVersion;\\n _CACHED_CHAIN_ID = block.chainid;\\n _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);\\n _CACHED_THIS = address(this);\\n _TYPE_HASH = typeHash;\\n }\\n\\n function DOMAIN_SEPARATOR() external view returns (bytes32) {\\n return _domainSeparatorV4();\\n }\\n\\n function totalSupply() external view virtual returns (uint256) {\\n return _totalSupply;\\n }\\n\\n function balanceOf(address account) external view virtual returns (uint256) {\\n return _balanceOf[account];\\n }\\n\\n function allowance(address owner, address spender) external view virtual returns (uint256) {\\n return _allowance[owner][spender];\\n }\\n\\n function _domainSeparatorV4() internal view returns (bytes32) {\\n if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {\\n return _CACHED_DOMAIN_SEPARATOR;\\n } else {\\n return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);\\n }\\n }\\n\\n function _buildDomainSeparator(\\n bytes32 typeHash,\\n bytes32 nameHash,\\n bytes32 versionHash\\n ) private view returns (bytes32) {\\n return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));\\n }\\n\\n function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {\\n return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);\\n }\\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 ) public virtual {\\n if (block.timestamp > deadline) revert Expired();\\n\\n bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline));\\n\\n bytes32 hash = _hashTypedDataV4(structHash);\\n\\n address signer = ECDSA.recover(hash, v, r, s);\\n if (signer != owner) revert InvalidSignature();\\n\\n _approve(owner, spender, value);\\n }\\n\\n function transferFrom(\\n address from,\\n address to,\\n uint256 amount\\n ) external returns (bool) {\\n if (_allowance[from][msg.sender] != type(uint256).max) {\\n _allowance[from][msg.sender] -= amount;\\n }\\n _transfer(from, to, amount);\\n return true;\\n }\\n\\n function transfer(address to, uint256 amount) external override returns (bool) {\\n _transfer(msg.sender, to, amount);\\n return true;\\n }\\n\\n function _transfer(\\n address from,\\n address to,\\n uint256 amount\\n ) internal virtual returns (uint256 balanceOfFrom, uint256 balanceOfTo) {\\n if (from == address(0)) revert InvalidSender();\\n if (to == address(0)) revert InvalidReceiver();\\n\\n uint256 balance = _balanceOf[from];\\n if (balance < amount) revert NotEnoughBalance();\\n unchecked {\\n balanceOfFrom = balance - amount;\\n balanceOfTo = _balanceOf[to] + amount;\\n _balanceOf[from] = balanceOfFrom;\\n _balanceOf[to] = balanceOfTo;\\n }\\n\\n emit Transfer(from, to, amount);\\n }\\n\\n function approve(address spender, uint256 amount) external override returns (bool) {\\n _approve(msg.sender, spender, amount);\\n return true;\\n }\\n\\n function _approve(\\n address owner,\\n address spender,\\n uint256 amount\\n ) internal virtual {\\n if (owner == address(0)) revert InvalidOwner();\\n if (spender == address(0)) revert InvalidSpender();\\n\\n _allowance[owner][spender] = amount;\\n emit Approval(owner, spender, amount);\\n }\\n\\n function _mint(address account, uint256 amount) internal virtual {\\n if (account == address(0)) revert InvalidAccount();\\n\\n _totalSupply += amount;\\n unchecked {\\n _balanceOf[account] += amount;\\n }\\n\\n emit Transfer(address(0), account, amount);\\n }\\n\\n function _burn(address account, uint256 amount) internal virtual {\\n if (account == address(0)) revert InvalidAccount();\\n\\n uint256 balance = _balanceOf[account];\\n if (balance < amount) revert NotEnoughBalance();\\n unchecked {\\n _balanceOf[account] = balance - amount;\\n _totalSupply -= amount;\\n }\\n\\n emit Transfer(account, address(0), amount);\\n }\\n}\\n\",\"keccak256\":\"0x4b3dc734d2703c5ff91466a26069ac5fddda062c0d08f82d64cab5c4157b28fb\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFarmingLPToken.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\ninterface IFarmingLPToken is IERC20 {\\n error InvalidPath();\\n error InsufficientYield();\\n error InsufficientAmount();\\n error NoMigratorSet();\\n\\n event Deposit(uint256 shares, uint256 amountLP, address indexed beneficiary);\\n event Withdraw(uint256 shares, uint256 amountLP, address indexed beneficiary);\\n event EmergencyWithdraw(uint256 shares, uint256 amountLP, address indexed beneficiary);\\n event ClaimSushi(uint256 shares, uint256 yield, address indexed beneficiary);\\n event Migrate(uint256 shares, uint256 amountLP, address indexed beneficiary);\\n event EmergencyMigrate(uint256 shares, uint256 amountLP, address indexed beneficiary);\\n\\n function initialize(\\n address _router,\\n address _masterChef,\\n uint256 _pid\\n ) external;\\n\\n function factory() external view returns (address);\\n\\n function router() external view returns (address);\\n\\n function masterChef() external view returns (address);\\n\\n function sushi() external view returns (address);\\n\\n function pid() external view returns (uint256);\\n\\n function lpToken() external view returns (address);\\n\\n function token0() external view returns (address);\\n\\n function token1() external view returns (address);\\n\\n function withdrawableTotalLPs() external view returns (uint256);\\n\\n function withdrawableLPsOf(address account) external view returns (uint256);\\n\\n function withdrawableTotalYield() external view returns (uint256);\\n\\n function withdrawableYieldOf(address account) external view returns (uint256);\\n\\n function totalShares() external view returns (uint256);\\n\\n function sharesOf(address account) external view returns (uint256);\\n\\n function approveMax() external;\\n\\n function depositSigned(\\n uint256 amountLP,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountMin,\\n address beneficiary,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external;\\n\\n function deposit(\\n uint256 amountLP,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountMin,\\n address beneficiary,\\n uint256 deadline\\n ) external;\\n\\n function depositWithSushi(\\n uint256 amount,\\n address[] calldata path0,\\n address[] calldata path1,\\n uint256 amountLPMin,\\n address beneficiary,\\n uint256 deadline\\n ) external;\\n\\n function withdraw(uint256 shares, address beneficiary) external;\\n\\n function emergencyWithdraw(address beneficiary) external;\\n\\n function migrate(address beneficiary, bytes calldata params) external;\\n\\n function emergencyMigrate(address beneficiary, bytes calldata params) external;\\n\\n function checkpoint() external;\\n}\\n\",\"keccak256\":\"0x72184ba706021d3c901e7481b624e95d3d43699335d159baf778de69a2edce5e\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFarmingLPTokenFactory.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\ninterface IFarmingLPTokenFactory {\\n error InvalidAddress();\\n error MigratorSet();\\n error TokenCreated();\\n\\n event UpdateVault(address indexed vault);\\n event UpdateMigrator(address indexed migrator);\\n event CreateFarmingLPToken(uint256 indexed pid, address indexed token);\\n\\n function router() external view returns (address);\\n\\n function masterChef() external view returns (address);\\n\\n function yieldVault() external view returns (address);\\n\\n function migrator() external view returns (address);\\n\\n function getFarmingLPToken(uint256 pid) external view returns (address);\\n\\n function predictFarmingLPTokenAddress(uint256 pid) external view returns (address token);\\n\\n function updateYieldVault(address vault) external;\\n\\n function updateMigrator(address vault) external;\\n\\n function createFarmingLPToken(uint256 pid) external returns (address token);\\n}\\n\",\"keccak256\":\"0x1cdd684bf0d94c6bce80efcc5b93761a02356bde314f4851f1ba82059378e5c4\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFarmingLPTokenMigrator.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\ninterface IFarmingLPTokenMigrator {\\n /**\\n * @dev address of legacy FarmingLPTokenFactory\\n */\\n function factoryLegacy() external view returns (address);\\n\\n /**\\n * @dev msg.sender MUST be factoryLegacy.getFarmingLPToken(lpToken)\\n */\\n function onMigrate(\\n address account,\\n uint256 pid,\\n address lpToken,\\n uint256 shares,\\n uint256 amountLP,\\n address beneficiary,\\n bytes calldata params\\n ) external;\\n}\\n\",\"keccak256\":\"0x50057a7cbe38ee789d7f95f10d23f73c76631c09375544b4557aafd585ef53da\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IMasterChef.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\ninterface IMasterChef {\\n function sushi() external view returns (address);\\n\\n function poolInfo(uint256 _pid)\\n external\\n view\\n returns (\\n address lpToken,\\n uint256 allocPoint,\\n uint256 lastRewardBlock,\\n uint256 accSushiPerShare\\n );\\n\\n function userInfo(uint256 _pid, address user) external view returns (uint256 amount, uint256 rewardDebt);\\n\\n function pendingSushi(uint256 _pid, address _user) external view returns (uint256);\\n\\n function deposit(uint256 _pid, uint256 _amount) external;\\n\\n function withdraw(uint256 _pid, uint256 _amount) external;\\n}\\n\",\"keccak256\":\"0x37ad9ebc83218a1920c0d0cdd29a51bf3fba8bb36f156b69c133195b85e0c0ae\",\"license\":\"BUSL-1.1\"},\"contracts/libraries/UniswapV2Utils.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Router02.sol\\\";\\n\\nlibrary UniswapV2Utils {\\n using SafeERC20 for IERC20;\\n\\n error InsufficientAmountLP();\\n\\n function quote(\\n address router,\\n uint256 amountIn,\\n address[] memory path\\n ) internal view returns (uint256 amountOut) {\\n if (path.length < 2) return amountIn;\\n\\n uint256[] memory amountsOut = IUniswapV2Router02(router).getAmountsOut(amountIn, path);\\n return amountsOut[amountsOut.length - 1];\\n }\\n\\n function addLiquidityWithSingleToken(\\n address router,\\n uint256 amount,\\n address[] memory path0,\\n address[] memory path1,\\n uint256 deadline\\n ) internal returns (uint256 amountLP) {\\n uint256 amountOut0 = swap(router, amount / 2, path0, deadline);\\n uint256 amountOut1 = swap(router, amount / 2, path1, deadline);\\n\\n (address token0, address token1) = (path0[path0.length - 1], path1[path1.length - 1]);\\n (, , uint256 _amountLP) = IUniswapV2Router02(router).addLiquidity(\\n token0,\\n token1,\\n amountOut0,\\n amountOut1,\\n 0,\\n 0,\\n address(this),\\n deadline\\n );\\n\\n uint256 balance0 = IERC20(token0).balanceOf(address(this));\\n if (balance0 > 0) {\\n IERC20(token0).safeTransfer(msg.sender, balance0);\\n }\\n uint256 balance1 = IERC20(token1).balanceOf(address(this));\\n if (balance1 > 0) {\\n IERC20(token1).safeTransfer(msg.sender, balance1);\\n }\\n\\n return _amountLP;\\n }\\n\\n function swap(\\n address router,\\n uint256 amountIn,\\n address[] memory path,\\n uint256 deadline\\n ) internal returns (uint256 amountOut) {\\n if (path.length < 2) return amountIn;\\n\\n uint256[] memory amountsOut = IUniswapV2Router02(router).swapExactTokensForTokens(\\n amountIn,\\n 0,\\n path,\\n address(this),\\n deadline\\n );\\n return amountsOut[amountsOut.length - 1];\\n }\\n}\\n\",\"keccak256\":\"0xb17b84a89979de550c183ed18c2c034b2de9b0df7a2636f88a2d4b9d4a31ebe3\",\"license\":\"BUSL-1.1\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "kind": "dev", "methods": { "owner()": { "details": "Returns the address of the current owner." }, "renounceOwnership()": { "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." }, "transferOwnership(address)": { "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." } }, "version": 1 }, "userdoc": { "kind": "user", "methods": {}, "version": 1 }, "storageLayout": { "storage": [ { "astId": 7, "contract": "contracts/FarmingLPTokenFactory.sol:FarmingLPTokenFactory", "label": "_owner", "offset": 0, "slot": "0", "type": "t_address" }, { "astId": 12648, "contract": "contracts/FarmingLPTokenFactory.sol:FarmingLPTokenFactory", "label": "yieldVault", "offset": 0, "slot": "1", "type": "t_address" }, { "astId": 12651, "contract": "contracts/FarmingLPTokenFactory.sol:FarmingLPTokenFactory", "label": "migrator", "offset": 0, "slot": "2", "type": "t_address" }, { "astId": 12656, "contract": "contracts/FarmingLPTokenFactory.sol:FarmingLPTokenFactory", "label": "getFarmingLPToken", "offset": 0, "slot": "3", "type": "t_mapping(t_uint256,t_address)" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_mapping(t_uint256,t_address)": { "encoding": "mapping", "key": "t_uint256", "label": "mapping(uint256 => address)", "numberOfBytes": "32", "value": "t_address" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" } } } }