{ "address": "0x8f77a1f6D36c6F3005B33E4071733C7057463Ca5", "abi": [ { "inputs": [ { "internalType": "address", "name": "fSushi", "type": "address" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "Bankrupt", "type": "error" }, { "inputs": [], "name": "InvalidAccount", "type": "error" }, { "inputs": [], "name": "InvalidDuration", "type": "error" }, { "inputs": [], "name": "NotEnoughBalance", "type": "error" }, { "inputs": [], "name": "QueueEmpty", "type": "error" }, { "inputs": [], "name": "WithdrawalDenied", "type": "error" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "sender", "type": "address" }, { "indexed": true, "internalType": "address", "name": "beneficiary", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "shares", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "assets", "type": "uint256" } ], "name": "Deposit", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "from", "type": "address" }, { "indexed": true, "internalType": "address", "name": "to", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "value", "type": "uint256" } ], "name": "Transfer", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "owner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "beneficiary", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "shares", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "assets", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "yield", "type": "uint256" } ], "name": "Withdraw", "type": "event" }, { "inputs": [], "name": "asset", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "balanceOf", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "checkpoint", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "checkpointedTotalAssets", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "week", "type": "uint256" } ], "name": "checkpointedTotalAssetsDuring", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "decimals", "outputs": [ { "internalType": "uint8", "name": "", "type": "uint8" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "assets", "type": "uint256" }, { "internalType": "uint256", "name": "_weeks", "type": "uint256" }, { "internalType": "address", "name": "beneficiary", "type": "address" } ], "name": "deposit", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "assets", "type": "uint256" }, { "internalType": "uint256", "name": "_weeks", "type": "uint256" }, { "internalType": "address", "name": "beneficiary", "type": "address" }, { "internalType": "uint256", "name": "deadline", "type": "uint256" }, { "internalType": "uint8", "name": "v", "type": "uint8" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "s", "type": "bytes32" } ], "name": "depositSigned", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "lastCheckpoint", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "name", "outputs": [ { "internalType": "string", "name": "", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "assets", "type": "uint256" }, { "internalType": "uint256", "name": "_weeks", "type": "uint256" } ], "name": "previewDeposit", "outputs": [ { "internalType": "uint256", "name": "shares", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "owner", "type": "address" } ], "name": "previewWithdraw", "outputs": [ { "internalType": "uint256", "name": "shares", "type": "uint256" }, { "internalType": "uint256", "name": "assets", "type": "uint256" }, { "internalType": "uint256", "name": "yield", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "startWeek", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "symbol", "outputs": [ { "internalType": "string", "name": "", "type": "string" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalAssets", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "name": "totalAssetsDuring", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalSupply", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "beneficiary", "type": "address" } ], "name": "withdraw", "outputs": [ { "internalType": "uint256", "name": "shares", "type": "uint256" }, { "internalType": "uint256", "name": "assets", "type": "uint256" }, { "internalType": "uint256", "name": "yield", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" } ], "transactionHash": "0x01e48f09342bfde5ca4da7536ee88dc67b5caa815e1031b63dc9b03648d256b3", "receipt": { "to": null, "from": "0x612ef87bfcd858687160294b0eFFACA0CBA342E2", "contractAddress": "0x8f77a1f6D36c6F3005B33E4071733C7057463Ca5", "transactionIndex": 118, "gasUsed": "1241301", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x30922e62fdaa80e1083cf55ff913e9d0b99a6c374d4596f8e15a208107439c25", "transactionHash": "0x01e48f09342bfde5ca4da7536ee88dc67b5caa815e1031b63dc9b03648d256b3", "logs": [], "blockNumber": 16343679, "cumulativeGasUsed": "12380024", "status": 1, "byzantium": true }, "args": [ "0xA24390c62186A8D265344e914F0Fd962B81b5F13" ], "numDeployments": 1, "solcInputHash": "8c17aa148ad85bf7109c5d60e7cb8c68", "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"fSushi\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"Bankrupt\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidDuration\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotEnoughBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"QueueEmpty\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalDenied\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"yield\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"asset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"checkpoint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"checkpointedTotalAssets\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"week\",\"type\":\"uint256\"}],\"name\":\"checkpointedTotalAssetsDuring\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_weeks\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_weeks\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"depositSigned\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastCheckpoint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_weeks\",\"type\":\"uint256\"}],\"name\":\"previewDeposit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"previewWithdraw\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"yield\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startWeek\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalAssets\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"totalAssetsDuring\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"assets\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"yield\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"checkpoint()\":{\"details\":\"if this function doesn't get called for 512 weeks (around 9.8 years) this contract breaks\"}},\"stateVariables\":{\"totalAssetsDuring\":{\"details\":\"this is guaranteed to be correct up until the last week\",\"return\":\"minimum number of staked total assets during the whole week\",\"returns\":{\"_0\":\"minimum number of staked total assets during the whole week\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"lastCheckpoint()\":{\"notice\":\"totalAssetsDuring is guaranteed to be correct before this week\"}},\"notice\":\"FSushiBar is an extension of ERC4626 with the addition of vesting period for locks\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/FSushiBar.sol\":\"FSushiBar\"},\"evmVersion\":\"london\",\"libraries\":{\":__CACHE_BREAKER__\":\"0x00000000d41867734bbee4c6863d9255b2b06ac1\"},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@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/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\"},\"contracts/FSushiBar.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport \\\"./interfaces/IFSushiBar.sol\\\";\\nimport \\\"./interfaces/IFSushi.sol\\\";\\nimport \\\"./libraries/FSushiBarPriorityQueue.sol\\\";\\nimport \\\"./libraries/DateUtils.sol\\\";\\n\\n/**\\n * @notice FSushiBar is an extension of ERC4626 with the addition of vesting period for locks\\n */\\ncontract FSushiBar is IFSushiBar {\\n using FSushiBarPriorityQueue for FSushiBarPriorityQueue.Heap;\\n using SafeERC20 for IERC20;\\n using Math for uint256;\\n using DateUtils for uint256;\\n\\n uint8 public constant decimals = 18;\\n string public constant name = \\\"Flash SushiBar\\\";\\n string public constant symbol = \\\"xfSUSHI\\\";\\n uint256 internal constant MINIMUM_WEEKS = 1;\\n uint256 internal constant MAXIMUM_WEEKS = 104; // almost 2 years\\n\\n address public immutable override asset;\\n uint256 public immutable override startWeek;\\n\\n mapping(address => uint256) public override balanceOf;\\n uint256 public override totalSupply;\\n\\n mapping(address => FSushiBarPriorityQueue.Heap) internal _locks;\\n\\n uint256 public override totalAssets;\\n /**\\n * @dev this is guaranteed to be correct up until the last week\\n * @return minimum number of staked total assets during the whole week\\n */\\n mapping(uint256 => uint256) public override totalAssetsDuring;\\n /**\\n * @notice totalAssetsDuring is guaranteed to be correct before this week\\n */\\n uint256 public override lastCheckpoint; // week\\n\\n uint256 internal _totalPower;\\n uint256 internal _totalYield;\\n\\n modifier validWeeks(uint256 _weeks) {\\n if (_weeks < MINIMUM_WEEKS || _weeks > MAXIMUM_WEEKS) revert InvalidDuration();\\n _;\\n }\\n\\n constructor(address fSushi) {\\n asset = fSushi;\\n\\n uint256 thisWeek = block.timestamp.toWeekNumber();\\n startWeek = thisWeek;\\n lastCheckpoint = thisWeek;\\n }\\n\\n function previewDeposit(uint256 assets, uint256 _weeks)\\n public\\n view\\n override\\n validWeeks(_weeks)\\n returns (uint256 shares)\\n {\\n return _toShares(_toPower(assets, _weeks), _totalPower);\\n }\\n\\n function previewWithdraw(address owner)\\n public\\n view\\n override\\n returns (\\n uint256 shares,\\n uint256 assets,\\n uint256 yield\\n )\\n {\\n (assets, , shares) = _locks[owner].enqueued(block.timestamp);\\n yield = _getYield(shares);\\n }\\n\\n function _toShares(uint256 power, uint256 totalPower) internal view returns (uint256 shares) {\\n uint256 supply = totalSupply;\\n shares = (power == 0 || supply == 0) ? power : power.mulDiv(supply, totalPower, Math.Rounding.Down);\\n }\\n\\n function _toPower(uint256 assets, uint256 _weeks) internal pure returns (uint256) {\\n return assets.mulDiv(_weeks, MAXIMUM_WEEKS, Math.Rounding.Up);\\n }\\n\\n function _getYield(uint256 shares) internal view returns (uint256 yield) {\\n uint256 _totalSupply = totalSupply;\\n if (_totalSupply == 0) return 0;\\n\\n return _totalYield.mulDiv(shares, _totalSupply, Math.Rounding.Down);\\n }\\n\\n function depositSigned(\\n uint256 assets,\\n uint256 _weeks,\\n address beneficiary,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) public override returns (uint256) {\\n IFSushi(asset).permit(msg.sender, address(this), assets, deadline, v, r, s);\\n\\n return deposit(assets, _weeks, beneficiary);\\n }\\n\\n function deposit(\\n uint256 assets,\\n uint256 _weeks,\\n address beneficiary\\n ) public override validWeeks(_weeks) returns (uint256) {\\n checkpoint();\\n\\n uint256 max = (totalAssets > 0 || totalSupply == 0) ? type(uint256).max : 0;\\n if (assets > max) revert Bankrupt();\\n\\n uint256 totalPower = _totalPower;\\n uint256 power = _toPower(assets, _weeks);\\n uint256 shares = _toShares(power, totalPower);\\n\\n IERC20(asset).safeTransferFrom(msg.sender, address(this), assets);\\n _mint(beneficiary, shares);\\n\\n _locks[msg.sender].enqueue(block.timestamp + _weeks * (1 weeks), assets, power, shares);\\n\\n totalAssets += assets;\\n totalAssetsDuring[block.timestamp.toWeekNumber()] += assets;\\n _totalPower = totalPower + power;\\n\\n emit Deposit(msg.sender, beneficiary, shares, assets);\\n\\n return shares;\\n }\\n\\n function withdraw(address beneficiary)\\n public\\n override\\n returns (\\n uint256 shares,\\n uint256 assets,\\n uint256 yield\\n )\\n {\\n checkpoint();\\n\\n uint256 power;\\n (assets, power, shares) = _locks[msg.sender].drain(block.timestamp);\\n if (shares == 0) revert WithdrawalDenied();\\n\\n yield = _getYield(shares);\\n totalAssets -= (assets + yield);\\n totalAssetsDuring[block.timestamp.toWeekNumber()] -= (assets + yield);\\n _totalPower -= power;\\n _totalYield -= yield;\\n\\n _burn(msg.sender, shares);\\n IERC20(asset).safeTransfer(beneficiary, assets + yield);\\n\\n emit Withdraw(msg.sender, beneficiary, shares, assets, yield);\\n }\\n\\n function checkpointedTotalAssets() external override returns (uint256) {\\n checkpoint();\\n return totalAssets;\\n }\\n\\n function checkpointedTotalAssetsDuring(uint256 week) external override returns (uint256) {\\n checkpoint();\\n return totalAssetsDuring[week];\\n }\\n\\n /**\\n * @dev if this function doesn't get called for 512 weeks (around 9.8 years) this contract breaks\\n */\\n function checkpoint() public override {\\n uint256 oldTotalAssets = totalAssets;\\n uint256 newTotalAssets = IERC20(asset).balanceOf(address(this));\\n if (newTotalAssets > oldTotalAssets) {\\n totalAssets = newTotalAssets;\\n totalAssetsDuring[block.timestamp.toWeekNumber()] = newTotalAssets;\\n _totalPower += newTotalAssets - oldTotalAssets;\\n _totalYield += newTotalAssets - oldTotalAssets;\\n }\\n\\n uint256 from = lastCheckpoint;\\n uint256 until = block.timestamp.toWeekNumber();\\n if (until <= from) return;\\n\\n for (uint256 i; i < 512; ) {\\n uint256 week = from + i;\\n if (until <= week) break;\\n\\n totalAssetsDuring[week + 1] = totalAssetsDuring[week];\\n\\n unchecked {\\n ++i;\\n }\\n }\\n\\n lastCheckpoint = until;\\n }\\n\\n function _mint(address account, uint256 amount) internal {\\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 {\\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\":\"0x790958e98bb9938888391792500c8f96cd760f0bc2d79a939456fdfcf6331b19\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFSushi.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\ninterface IFSushi is IERC20Metadata {\\n error Forbidden();\\n error Expired();\\n error MintersLocked();\\n error InvalidSignature();\\n\\n event SetMinter(address indexed account, bool indexed isMinter);\\n event LockMinters();\\n event Checkpoint(uint256 lastCheckpoint);\\n\\n function DOMAIN_SEPARATOR() external view returns (bytes32);\\n\\n function startWeek() external view returns (uint256);\\n\\n function isMinter(address account) external view returns (bool);\\n\\n function mintersLocked() external view returns (bool);\\n\\n function nonces(address account) external view returns (uint256);\\n\\n function totalSupplyDuring(uint256 time) external view returns (uint256);\\n\\n function lastCheckpoint() external view returns (uint256);\\n\\n function setMinter(address account, bool _isMinter) external;\\n\\n function lockMinters() external;\\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 function mint(address to, uint256 amount) external;\\n\\n function checkpointedTotalSupplyDuring(uint256 week) external returns (uint256);\\n\\n function checkpoint() external;\\n}\\n\",\"keccak256\":\"0xcddcbb7b60b3644005a7c2c9ac10303b73a6e46a316312cd42c1fb393eb2f7e3\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFSushiBar.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IFSushiRestaurant.sol\\\";\\n\\ninterface IFSushiBar is IFSushiRestaurant {\\n error Bankrupt();\\n error InvalidDuration();\\n error InvalidAccount();\\n error NotEnoughBalance();\\n error WithdrawalDenied();\\n\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n event Deposit(address indexed sender, address indexed beneficiary, uint256 shares, uint256 assets);\\n event Withdraw(address indexed owner, address indexed beneficiary, uint256 shares, uint256 assets, uint256 yield);\\n\\n function asset() external view returns (address);\\n\\n function name() external view returns (string memory);\\n\\n function symbol() external view returns (string memory);\\n\\n function decimals() external view returns (uint8);\\n\\n function totalSupply() external view returns (uint256);\\n\\n function balanceOf(address account) external view returns (uint256);\\n\\n function previewDeposit(uint256 assets, uint256 _weeks) external view returns (uint256 shares);\\n\\n function previewWithdraw(address owner)\\n external\\n view\\n returns (\\n uint256 shares,\\n uint256 assets,\\n uint256 yield\\n );\\n\\n function depositSigned(\\n uint256 assets,\\n uint256 _weeks,\\n address receiver,\\n uint256 deadline,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) external returns (uint256);\\n\\n function deposit(\\n uint256 assets,\\n uint256 _weeks,\\n address receiver\\n ) external returns (uint256);\\n\\n function withdraw(address beneficiary)\\n external\\n returns (\\n uint256 shares,\\n uint256 assets,\\n uint256 yield\\n );\\n}\\n\",\"keccak256\":\"0x4fdbe1f2aab3c71433d6cdb6a699d643ae2b4873c1beeab4d543cb0a5bf44a21\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFSushiRestaurant.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\ninterface IFSushiRestaurant {\\n function startWeek() external view returns (uint256);\\n\\n function totalAssets() external view returns (uint256);\\n\\n function totalAssetsDuring(uint256 week) external view returns (uint256);\\n\\n function lastCheckpoint() external view returns (uint256);\\n\\n function checkpointedTotalAssets() external returns (uint256);\\n\\n function checkpointedTotalAssetsDuring(uint256 week) external returns (uint256);\\n\\n function checkpoint() external;\\n}\\n\",\"keccak256\":\"0xc9f77acbb7bd60b62503caf82313069efa9897b846266fa2abe047c3947ebafd\",\"license\":\"BUSL-1.1\"},\"contracts/libraries/DateUtils.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nuint256 constant WEEK = 1 weeks;\\n\\nlibrary DateUtils {\\n function toWeekNumber(uint256 timestamp) internal pure returns (uint256) {\\n return timestamp / WEEK;\\n }\\n\\n function toTimestamp(uint256 weekNumber) internal pure returns (uint256) {\\n return weekNumber * WEEK;\\n }\\n}\\n\",\"keccak256\":\"0x1f6685854a201369d06bcbaf873bc0a39ac0c4f40a22f06a5ac86b9b2cf5542f\",\"license\":\"BUSL-1.1\"},\"contracts/libraries/FSushiBarPriorityQueue.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\n// modified https://github.com/MihanixA/SummingPriorityQueue/blob/master/contracts/SummingPriorityQueue.sol\\nlibrary FSushiBarPriorityQueue {\\n error QueueEmpty();\\n\\n struct Snapshot {\\n uint256 assets;\\n uint256 power;\\n uint256 shares;\\n }\\n\\n struct Heap {\\n uint256[] timestamps;\\n mapping(uint256 => Snapshot) snapshots;\\n }\\n\\n modifier notEmpty(Heap storage self) {\\n if (self.timestamps.length == 1) revert QueueEmpty();\\n _;\\n }\\n\\n function top(Heap storage self) internal view notEmpty(self) returns (uint256) {\\n return self.timestamps[1];\\n }\\n\\n /**\\n * @dev average time complexity: O(log n), worst-case time complexity: O(n)\\n */\\n function enqueued(Heap storage self, uint256 timestamp)\\n internal\\n view\\n returns (\\n uint256 assets,\\n uint256 power,\\n uint256 shares\\n )\\n {\\n return _dfs(self, timestamp, 1);\\n }\\n\\n function _dfs(\\n Heap storage self,\\n uint256 timestamp,\\n uint256 i\\n )\\n private\\n view\\n returns (\\n uint256 assets,\\n uint256 power,\\n uint256 shares\\n )\\n {\\n if (i >= self.timestamps.length) return (0, 0, 0);\\n if (self.timestamps[i] > timestamp) return (0, 0, 0);\\n\\n Snapshot memory snapshot = self.snapshots[self.timestamps[i]];\\n assets = snapshot.assets;\\n power = snapshot.power;\\n shares = snapshot.shares;\\n\\n (uint256 assetsLeft, uint256 powerLeft, uint256 sharesLeft) = _dfs(self, timestamp, i * 2);\\n (uint256 assetsRight, uint256 powerRight, uint256 sharesRight) = _dfs(self, timestamp, i * 2 + 1);\\n return (assets + assetsLeft + assetsRight, power + powerLeft + powerRight, shares + sharesLeft + sharesRight);\\n }\\n\\n function enqueue(\\n Heap storage self,\\n uint256 timestamp,\\n uint256 assets,\\n uint256 power,\\n uint256 shares\\n ) internal {\\n if (self.timestamps.length == 0) self.timestamps.push(0); // initialize\\n\\n self.timestamps.push(timestamp);\\n uint256 i = self.timestamps.length - 1;\\n\\n while (i > 1 && self.timestamps[i / 2] > self.timestamps[i]) {\\n (self.timestamps[i / 2], self.timestamps[i]) = (timestamp, self.timestamps[i / 2]);\\n i /= 2;\\n }\\n\\n self.snapshots[timestamp] = Snapshot(assets, power, shares);\\n }\\n\\n function dequeue(Heap storage self)\\n internal\\n notEmpty(self)\\n returns (\\n uint256 timestamp,\\n uint256 assets,\\n uint256 power,\\n uint256 shares\\n )\\n {\\n if (self.timestamps.length == 1) revert QueueEmpty();\\n\\n timestamp = top(self);\\n self.timestamps[1] = self.timestamps[self.timestamps.length - 1];\\n self.timestamps.pop();\\n\\n uint256 i = 1;\\n\\n while (i * 2 < self.timestamps.length) {\\n uint256 j = i * 2;\\n\\n if (j + 1 < self.timestamps.length)\\n if (self.timestamps[j] > self.timestamps[j + 1]) j++;\\n\\n if (self.timestamps[i] < self.timestamps[j]) break;\\n\\n (self.timestamps[i], self.timestamps[j]) = (self.timestamps[j], self.timestamps[i]);\\n i = j;\\n }\\n\\n Snapshot memory snapshot = self.snapshots[timestamp];\\n delete self.snapshots[timestamp];\\n\\n return (timestamp, snapshot.assets, snapshot.power, snapshot.shares);\\n }\\n\\n function drain(Heap storage self, uint256 timestamp)\\n internal\\n returns (\\n uint256 assetsDequeued,\\n uint256 powerDequeued,\\n uint256 sharesDequeued\\n )\\n {\\n while (self.timestamps.length > 1 && top(self) < timestamp) {\\n (, uint256 assets, uint256 power, uint256 shares) = dequeue(self);\\n assetsDequeued += assets;\\n powerDequeued += power;\\n sharesDequeued += shares;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x306e0f74b5558c02a2778d1f4b9c909a9c6a1a3c51b0682114fc895578490444\",\"license\":\"BUSL-1.1\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "kind": "dev", "methods": { "checkpoint()": { "details": "if this function doesn't get called for 512 weeks (around 9.8 years) this contract breaks" } }, "stateVariables": { "totalAssetsDuring": { "details": "this is guaranteed to be correct up until the last week", "return": "minimum number of staked total assets during the whole week", "returns": { "_0": "minimum number of staked total assets during the whole week" } } }, "version": 1 }, "userdoc": { "kind": "user", "methods": { "lastCheckpoint()": { "notice": "totalAssetsDuring is guaranteed to be correct before this week" } }, "notice": "FSushiBar is an extension of ERC4626 with the addition of vesting period for locks", "version": 1 }, "storageLayout": { "storage": [ { "astId": 9425, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "balanceOf", "offset": 0, "slot": "0", "type": "t_mapping(t_address,t_uint256)" }, { "astId": 9428, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "totalSupply", "offset": 0, "slot": "1", "type": "t_uint256" }, { "astId": 9433, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "_locks", "offset": 0, "slot": "2", "type": "t_mapping(t_address,t_struct(Heap)16703_storage)" }, { "astId": 9436, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "totalAssets", "offset": 0, "slot": "3", "type": "t_uint256" }, { "astId": 9442, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "totalAssetsDuring", "offset": 0, "slot": "4", "type": "t_mapping(t_uint256,t_uint256)" }, { "astId": 9446, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "lastCheckpoint", "offset": 0, "slot": "5", "type": "t_uint256" }, { "astId": 9448, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "_totalPower", "offset": 0, "slot": "6", "type": "t_uint256" }, { "astId": 9450, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "_totalYield", "offset": 0, "slot": "7", "type": "t_uint256" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_array(t_uint256)dyn_storage": { "base": "t_uint256", "encoding": "dynamic_array", "label": "uint256[]", "numberOfBytes": "32" }, "t_mapping(t_address,t_struct(Heap)16703_storage)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => struct FSushiBarPriorityQueue.Heap)", "numberOfBytes": "32", "value": "t_struct(Heap)16703_storage" }, "t_mapping(t_address,t_uint256)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => uint256)", "numberOfBytes": "32", "value": "t_uint256" }, "t_mapping(t_uint256,t_struct(Snapshot)16694_storage)": { "encoding": "mapping", "key": "t_uint256", "label": "mapping(uint256 => struct FSushiBarPriorityQueue.Snapshot)", "numberOfBytes": "32", "value": "t_struct(Snapshot)16694_storage" }, "t_mapping(t_uint256,t_uint256)": { "encoding": "mapping", "key": "t_uint256", "label": "mapping(uint256 => uint256)", "numberOfBytes": "32", "value": "t_uint256" }, "t_struct(Heap)16703_storage": { "encoding": "inplace", "label": "struct FSushiBarPriorityQueue.Heap", "members": [ { "astId": 16697, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "timestamps", "offset": 0, "slot": "0", "type": "t_array(t_uint256)dyn_storage" }, { "astId": 16702, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "snapshots", "offset": 0, "slot": "1", "type": "t_mapping(t_uint256,t_struct(Snapshot)16694_storage)" } ], "numberOfBytes": "64" }, "t_struct(Snapshot)16694_storage": { "encoding": "inplace", "label": "struct FSushiBarPriorityQueue.Snapshot", "members": [ { "astId": 16689, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "assets", "offset": 0, "slot": "0", "type": "t_uint256" }, { "astId": 16691, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "power", "offset": 0, "slot": "1", "type": "t_uint256" }, { "astId": 16693, "contract": "contracts/FSushiBar.sol:FSushiBar", "label": "shares", "offset": 0, "slot": "2", "type": "t_uint256" } ], "numberOfBytes": "96" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" } } } }