{
  "address": "0x77b8E6e577fd3e90553dbF205D3854a649414741",
  "abi": [
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_flashProtocol",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_flpTokenFactory",
          "type": "address"
        },
        {
          "internalType": "address",
          "name": "_feeRecipient",
          "type": "address"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "constructor"
    },
    {
      "inputs": [],
      "name": "FlashStrategySushiSwapCreated",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidFee",
      "type": "error"
    },
    {
      "inputs": [],
      "name": "InvalidFeeRecipient",
      "type": "error"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "pid",
          "type": "uint256"
        },
        {
          "indexed": false,
          "internalType": "address",
          "name": "strategy",
          "type": "address"
        }
      ],
      "name": "CreateFlashStrategySushiSwap",
      "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": false,
          "internalType": "address",
          "name": "feeRecipient",
          "type": "address"
        }
      ],
      "name": "UpdateFeeRecipient",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "fee",
          "type": "uint256"
        }
      ],
      "name": "UpdateFlashStakeFeeBPS",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": false,
          "internalType": "uint256",
          "name": "fee",
          "type": "uint256"
        }
      ],
      "name": "UpdateStakeFeeBPS",
      "type": "event"
    },
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "pid",
          "type": "uint256"
        }
      ],
      "name": "createFlashStrategySushiSwap",
      "outputs": [
        {
          "internalType": "address",
          "name": "strategy",
          "type": "address"
        }
      ],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "feeRecipient",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "flashProtocol",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "flpTokenFactory",
      "outputs": [
        {
          "internalType": "address",
          "name": "",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "uint256",
          "name": "",
          "type": "uint256"
        }
      ],
      "name": "getFlashStrategySushiSwap",
      "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": "predictFlashStrategySushiSwapAddress",
      "outputs": [
        {
          "internalType": "address",
          "name": "token",
          "type": "address"
        }
      ],
      "stateMutability": "view",
      "type": "function"
    },
    {
      "inputs": [],
      "name": "renounceOwnership",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "newOwner",
          "type": "address"
        }
      ],
      "name": "transferOwnership",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "_feeRecipient",
          "type": "address"
        }
      ],
      "name": "updateFeeRecipient",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    }
  ],
  "transactionHash": "0x5a1d1800f4a2f646c9a7d5b37ae452935813307c703812ffe0708e0a57cf22c1",
  "receipt": {
    "to": null,
    "from": "0x612ef87bfcd858687160294b0eFFACA0CBA342E2",
    "contractAddress": "0x77b8E6e577fd3e90553dbF205D3854a649414741",
    "transactionIndex": 113,
    "gasUsed": "1590606",
    "logsBloom": "0x00000000000000000000000000010200000000000000000000800000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000001000000000000000080000000000000000000020000000000000000000800000000000000000000000000000088400000000000000000000000000400000000000000000080000000000000000000000000000002000000000000000400002000000000200000000000000000000000000000000020000000000000040000000000000000000000000000000020000000000000000000000000000000020000000000000000000000000000000000",
    "blockHash": "0x438294317580628cd0bce2f2c9304d9961977467fa9a47cb54d3dba6ea2a1f0f",
    "transactionHash": "0x5a1d1800f4a2f646c9a7d5b37ae452935813307c703812ffe0708e0a57cf22c1",
    "logs": [
      {
        "transactionIndex": 113,
        "blockNumber": 16343678,
        "transactionHash": "0x5a1d1800f4a2f646c9a7d5b37ae452935813307c703812ffe0708e0a57cf22c1",
        "address": "0x77b8E6e577fd3e90553dbF205D3854a649414741",
        "topics": [
          "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0",
          "0x0000000000000000000000000000000000000000000000000000000000000000",
          "0x000000000000000000000000612ef87bfcd858687160294b0effaca0cba342e2"
        ],
        "data": "0x",
        "logIndex": 250,
        "blockHash": "0x438294317580628cd0bce2f2c9304d9961977467fa9a47cb54d3dba6ea2a1f0f"
      },
      {
        "transactionIndex": 113,
        "blockNumber": 16343678,
        "transactionHash": "0x5a1d1800f4a2f646c9a7d5b37ae452935813307c703812ffe0708e0a57cf22c1",
        "address": "0x77b8E6e577fd3e90553dbF205D3854a649414741",
        "topics": [
          "0x6632de8ab33c46549f7bb29f647ea0d751157b25fe6a14b1bcc7527cdfbeb79c"
        ],
        "data": "0x0000000000000000000000000903f8892c06a99bf1d68088fab597a0762e0bc8",
        "logIndex": 251,
        "blockHash": "0x438294317580628cd0bce2f2c9304d9961977467fa9a47cb54d3dba6ea2a1f0f"
      },
      {
        "transactionIndex": 113,
        "blockNumber": 16343678,
        "transactionHash": "0x5a1d1800f4a2f646c9a7d5b37ae452935813307c703812ffe0708e0a57cf22c1",
        "address": "0x3A03728A1aE344CA59f11465657e39cB8bBEE164",
        "topics": [
          "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498"
        ],
        "data": "0x0000000000000000000000000000000000000000000000000000000000000001",
        "logIndex": 252,
        "blockHash": "0x438294317580628cd0bce2f2c9304d9961977467fa9a47cb54d3dba6ea2a1f0f"
      }
    ],
    "blockNumber": 16343678,
    "cumulativeGasUsed": "14678573",
    "status": 1,
    "byzantium": true
  },
  "args": [
    "0x78b2d65dd1d3d9Fb2972d7Ef467261Ca101EC2B9",
    "0xEE083E0F0f5dE2ff34662F1ef6f76d897d5047EF",
    "0x0903f8892c06A99bf1D68088fAB597a0762e0BC8"
  ],
  "numDeployments": 1,
  "solcInputHash": "8c17aa148ad85bf7109c5d60e7cb8c68",
  "metadata": "{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_flashProtocol\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_flpTokenFactory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_feeRecipient\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"FlashStrategySushiSwapCreated\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFeeRecipient\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"pid\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"strategy\",\"type\":\"address\"}],\"name\":\"CreateFlashStrategySushiSwap\",\"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\":false,\"internalType\":\"address\",\"name\":\"feeRecipient\",\"type\":\"address\"}],\"name\":\"UpdateFeeRecipient\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"UpdateFlashStakeFeeBPS\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"}],\"name\":\"UpdateStakeFeeBPS\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"pid\",\"type\":\"uint256\"}],\"name\":\"createFlashStrategySushiSwap\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"strategy\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeRecipient\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashProtocol\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flpTokenFactory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"getFlashStrategySushiSwap\",\"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\":\"predictFlashStrategySushiSwapAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_feeRecipient\",\"type\":\"address\"}],\"name\":\"updateFeeRecipient\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"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\":{\"feeRecipient()\":{\"notice\":\"fee recipient\"},\"flashProtocol()\":{\"notice\":\"address of FlashProtocol\"},\"flpTokenFactory()\":{\"notice\":\"address of FarmingLPTokenFactory\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/FlashStrategySushiSwapFactory.sol\":\"FlashStrategySushiSwapFactory\"},\"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/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\"},\"contracts/FlashStrategySushiSwap.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.17;\\n\\nimport \\\"@openzeppelin/contracts/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts/security/ReentrancyGuard.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"./interfaces/IFlashStrategySushiSwap.sol\\\";\\nimport \\\"./interfaces/IFlashStrategySushiSwapFactory.sol\\\";\\nimport \\\"./interfaces/IFlashFToken.sol\\\";\\nimport \\\"./interfaces/IFarmingLPToken.sol\\\";\\nimport \\\"./interfaces/IERC20Receiver.sol\\\";\\n\\ncontract FlashStrategySushiSwap is Initializable, ReentrancyGuard, IFlashStrategySushiSwap {\\n    using SafeERC20 for IERC20;\\n\\n    address public override factory;\\n\\n    /**\\n     * @notice address of FlashProtocol\\n     */\\n    address public override flashProtocol;\\n\\n    /**\\n     * @notice address of SUSHI token\\n     */\\n    address public override sushi;\\n    /**\\n     * @notice address of FarmingLPToken\\n     */\\n    address public override flpToken;\\n\\n    uint256 internal _balancePrincipal;\\n\\n    /**\\n     * @notice address of fERC20 for this strategy\\n     */\\n    address public override fToken;\\n\\n    function initialize(address _flashProtocol, address _flpToken) external override initializer {\\n        if (_flashProtocol == address(0)) return;\\n\\n        factory = msg.sender;\\n        flashProtocol = _flashProtocol;\\n        sushi = IFarmingLPToken(_flpToken).sushi();\\n        flpToken = _flpToken;\\n    }\\n\\n    modifier onlyAuthorised() {\\n        if (msg.sender != flashProtocol && msg.sender != address(this)) revert Forbidden();\\n        _;\\n    }\\n\\n    /**\\n     * @return amount of principal tokens that are currently deposited\\n     */\\n    function getPrincipalBalance() external view override returns (uint256) {\\n        return _balancePrincipal;\\n    }\\n\\n    /**\\n     * @return amount of yield tokens that can be rewarded in SUSHI\\n     */\\n    function getYieldBalance() public view override returns (uint256) {\\n        return IFarmingLPToken(flpToken).withdrawableYieldOf(address(this));\\n    }\\n\\n    /**\\n     * @return address of LP Token\\n     */\\n    function getPrincipalAddress() external view override returns (address) {\\n        return flpToken;\\n    }\\n\\n    /**\\n     * @dev called by flashProtocol\\n     * @return amountFToken how many fTokens should be minted for a given _amount and _duration (in seconds)\\n     */\\n    function quoteMintFToken(uint256 _amount, uint256 _duration) external pure override returns (uint256 amountFToken) {\\n        // 1 fToken per 1 year\\n        uint256 amountToMint = (_amount * _duration) / 365 days;\\n\\n        if (amountToMint == 0) revert AmountTooLow();\\n\\n        return amountToMint;\\n    }\\n\\n    /**\\n     * @return how many aLP rewards should be returned if _amount fERC20 tokens are burned\\n     */\\n    function quoteBurnFToken(uint256 _amount) public view override returns (uint256) {\\n        uint256 totalSupply = IERC20(fToken).totalSupply();\\n        if (totalSupply == 0) revert InsufficientTotalSupply();\\n\\n        if (_amount > totalSupply) {\\n            _amount = totalSupply;\\n        }\\n\\n        return (getYieldBalance() * _amount) / totalSupply;\\n    }\\n\\n    function getMaxStakeDuration() public pure override returns (uint256) {\\n        return 104 weeks; // almost 2 years\\n    }\\n\\n    /**\\n     * @dev called by flashProtocol\\n     */\\n    function setFTokenAddress(address _fTokenAddress) external override {\\n        if (msg.sender != flashProtocol) revert Forbidden();\\n        fToken = _fTokenAddress;\\n    }\\n\\n    /**\\n     * @notice This function will be called whenever a user stakes via the Flash Protocol.\\n     * @dev The Strategy owner can choose to implement a fee but the resulting \\\"locked\\\" principal the user should expect\\n     *  after the stake has ended must be returned.\\n     */\\n    function depositPrincipal(uint256 _amount) external override onlyAuthorised returns (uint256) {\\n        uint256 fee = _amount / 400; // charge 0.25%\\n        _transferFee(flpToken, fee);\\n\\n        uint256 amount = _amount - fee;\\n        _balancePrincipal += amount;\\n\\n        return amount;\\n    }\\n\\n    /**\\n     * @notice This function should withdraw principal from the underlying strategy.\\n     */\\n    function withdrawPrincipal(uint256 _amount) external override onlyAuthorised {\\n        address _flpToken = flpToken;\\n        IFarmingLPToken(_flpToken).checkpoint();\\n\\n        IERC20(_flpToken).safeTransfer(msg.sender, _amount);\\n        _balancePrincipal -= _amount;\\n    }\\n\\n    /**\\n     * @notice This is the function the user will be calling when performing a FlashBurn.\\n     * @dev It is responsible for burning the fToken supplied by the user and returning yield to the user.\\n     */\\n    function burnFToken(\\n        uint256 _amount,\\n        uint256 _minimumReturned,\\n        address _yieldTo\\n    ) external override nonReentrant returns (uint256) {\\n        uint256 yield = quoteBurnFToken(_amount);\\n        if (yield == 0 || yield < _minimumReturned) revert InsufficientYield();\\n\\n        IFlashFToken(fToken).burnFrom(msg.sender, _amount);\\n\\n        address _flpToken = flpToken;\\n        IFarmingLPToken(_flpToken).withdraw(yield, address(this));\\n\\n        address lpToken = IFarmingLPToken(_flpToken).lpToken();\\n        uint256 balanceLPToken = IERC20(lpToken).balanceOf(address(this));\\n        _transfer(lpToken, _yieldTo, balanceLPToken);\\n\\n        address _sushi = sushi;\\n        uint256 balanceSushi = IERC20(_sushi).balanceOf(address(this));\\n        _transfer(_sushi, _yieldTo, balanceSushi);\\n\\n        emit BurnedFToken(msg.sender, _amount, yield);\\n\\n        return yield;\\n    }\\n\\n    function _transfer(\\n        address token,\\n        address to,\\n        uint256 amount\\n    ) internal {\\n        uint256 fee = amount / 100; // charge 1%\\n        IERC20(token).safeTransfer(to, amount - fee);\\n        _transferFee(token, fee);\\n    }\\n\\n    function _transferFee(address token, uint256 amount) internal {\\n        if (amount > 0) {\\n            address feeRecipient = IFlashStrategySushiSwapFactory(factory).feeRecipient();\\n            IERC20(token).safeTransfer(feeRecipient, amount);\\n            if (feeRecipient.code.length > 0) {\\n                try IERC20Receiver(feeRecipient).onReceiveERC20(token, address(this), amount) {} catch {}\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x32a73c196a75885161c6b0aa52e3414c69776ed2e42d8f4a04802d1eab07ad9a\",\"license\":\"BUSL-1.1\"},\"contracts/FlashStrategySushiSwapFactory.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 \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport \\\"./interfaces/IFarmingLPTokenFactory.sol\\\";\\nimport \\\"./interfaces/IFlashStrategySushiSwapFactory.sol\\\";\\nimport \\\"./FlashStrategySushiSwap.sol\\\";\\n\\ninterface IFlashProtocol {\\n    function registerStrategy(\\n        address _strategyAddress,\\n        address _principalTokenAddress,\\n        string calldata _fTokenName,\\n        string calldata _fTokenSymbol\\n    ) external;\\n}\\n\\ncontract FlashStrategySushiSwapFactory is Ownable, IFlashStrategySushiSwapFactory {\\n    bytes16 private constant _SYMBOLS = \\\"0123456789abcdef\\\";\\n\\n    /**\\n     * @notice address of FlashProtocol\\n     */\\n    address public immutable override flashProtocol;\\n    /**\\n     * @notice address of FarmingLPTokenFactory\\n     */\\n    address public immutable override flpTokenFactory;\\n\\n    address internal immutable _implementation;\\n\\n    /**\\n     * @notice fee recipient\\n     */\\n    address public override feeRecipient;\\n\\n    mapping(uint256 => address) public override getFlashStrategySushiSwap;\\n\\n    constructor(\\n        address _flashProtocol,\\n        address _flpTokenFactory,\\n        address _feeRecipient\\n    ) {\\n        flashProtocol = _flashProtocol;\\n        flpTokenFactory = _flpTokenFactory;\\n        updateFeeRecipient(_feeRecipient);\\n\\n        FlashStrategySushiSwap strategy = new FlashStrategySushiSwap();\\n        strategy.initialize(address(0), address(0));\\n        _implementation = address(strategy);\\n    }\\n\\n    function predictFlashStrategySushiSwapAddress(uint256 pid) external view override returns (address token) {\\n        token = Clones.predictDeterministicAddress(_implementation, bytes32(pid));\\n    }\\n\\n    function updateFeeRecipient(address _feeRecipient) public override onlyOwner {\\n        if (_feeRecipient == address(0)) revert InvalidFeeRecipient();\\n\\n        feeRecipient = _feeRecipient;\\n\\n        emit UpdateFeeRecipient(_feeRecipient);\\n    }\\n\\n    function createFlashStrategySushiSwap(uint256 pid) external override returns (address strategy) {\\n        if (getFlashStrategySushiSwap[pid] != address(0)) revert FlashStrategySushiSwapCreated();\\n\\n        address flpToken = IFarmingLPTokenFactory(flpTokenFactory).getFarmingLPToken(pid);\\n        if (flpToken == address(0)) flpToken = IFarmingLPTokenFactory(flpTokenFactory).createFarmingLPToken(pid);\\n\\n        strategy = Clones.cloneDeterministic(_implementation, bytes32(pid));\\n        FlashStrategySushiSwap(strategy).initialize(flashProtocol, flpToken);\\n\\n        getFlashStrategySushiSwap[pid] = strategy;\\n\\n        string memory name = string.concat(\\\"fToken for \\\", IERC20Metadata(flpToken).name());\\n        string memory symbol = string.concat(\\n            \\\"f\\\",\\n            IERC20Metadata(flpToken).symbol(),\\n            \\\"-\\\",\\n            _toHexString(uint160(flpToken) >> 144, 4)\\n        );\\n        IFlashProtocol(flashProtocol).registerStrategy(strategy, flpToken, name, symbol);\\n\\n        emit CreateFlashStrategySushiSwap(pid, strategy);\\n    }\\n\\n    function _toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\\n        bytes memory buffer = new bytes(length);\\n        for (uint256 i = 0; i < length; ) {\\n            buffer[length - i - 1] = _SYMBOLS[value & 0xf];\\n            value >>= 4;\\n            unchecked {\\n                ++i;\\n            }\\n        }\\n        return string(buffer);\\n    }\\n}\\n\",\"keccak256\":\"0x15ede416aea2e9af3d88399e536b17ae03d997afd116ff9c00341ee84a7e5340\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IERC20Receiver.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\ninterface IERC20Receiver {\\n    function onReceiveERC20(\\n        address token,\\n        address from,\\n        uint256 amount\\n    ) external;\\n}\\n\",\"keccak256\":\"0x06eaf9587ae46edb7c6e4e0444bd82d2101e3fc73a76b124abd8ce5622c270e1\",\"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/IFlashFToken.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\ninterface IFlashFToken {\\n    function mint(address account, uint256 amount) external;\\n\\n    function burnFrom(address from, uint256 amount) external;\\n\\n    function decimals() external returns (uint8);\\n}\\n\",\"keccak256\":\"0xc5a70953076ad87466ae73751f3e6e7a8426dfed79d21f8630c7eef6a0b62e02\",\"license\":\"MIT\"},\"contracts/interfaces/IFlashStrategy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.4;\\n\\ninterface IFlashStrategy {\\n    event BurnedFToken(address indexed _address, uint256 _tokenAmount, uint256 _yieldReturned);\\n\\n    // This is how principal will be deposited into the contract\\n    // The Flash protocol allows the strategy to specify how much\\n    // should be registered. This allows the strategy to manipulate (eg take fee)\\n    // on the principal if the strategy requires\\n    function depositPrincipal(uint256 _tokenAmount) external returns (uint256);\\n\\n    // This is how principal will be returned from the contract\\n    function withdrawPrincipal(uint256 _tokenAmount) external;\\n\\n    // Responsible for instant upfront yield. Takes fERC20 tokens specific to this\\n    // strategy. The strategy is responsible for returning some amount of principal tokens\\n    function burnFToken(\\n        uint256 _tokenAmount,\\n        uint256 _minimumReturned,\\n        address _yieldTo\\n    ) external returns (uint256);\\n\\n    // This should return the current total of all principal within the contract\\n    function getPrincipalBalance() external view returns (uint256);\\n\\n    // This should return the current total of all yield generated to date (including bootstrapped tokens)\\n    function getYieldBalance() external view returns (uint256);\\n\\n    // This should return the principal token address (eg DAI)\\n    function getPrincipalAddress() external view returns (address);\\n\\n    // View function which quotes how many principal tokens would be returned if x\\n    // fERC20 tokens are burned\\n    function quoteMintFToken(uint256 _tokenAmount, uint256 duration) external view returns (uint256);\\n\\n    // View function which quotes how many principal tokens would be returned if x\\n    // fERC20 tokens are burned\\n    // IMPORTANT NOTE: This should utilise bootstrap tokens if they exist\\n    // bootstrapped tokens are any principal tokens that exist within the smart contract\\n    function quoteBurnFToken(uint256 _tokenAmount) external view returns (uint256);\\n\\n    // The function to set the fERC20 address within the strategy\\n    function setFTokenAddress(address _fTokenAddress) external;\\n\\n    // This should return what the maximum stake duration is\\n    function getMaxStakeDuration() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8c72e893e2c11a247880fbacf8a0f761268797b789d269f7e0714c00efd5b988\",\"license\":\"MIT\"},\"contracts/interfaces/IFlashStrategySushiSwap.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"./IFlashStrategy.sol\\\";\\n\\ninterface IFlashStrategySushiSwap is IFlashStrategy {\\n    error Forbidden();\\n    error InvalidVault();\\n    error AmountTooLow();\\n    error InsufficientYield();\\n    error InsufficientTotalSupply();\\n\\n    function factory() external view returns (address);\\n\\n    function flashProtocol() external view returns (address);\\n\\n    function fToken() external view returns (address);\\n\\n    function sushi() external view returns (address);\\n\\n    function flpToken() external view returns (address);\\n\\n    function initialize(address _flashProtocol, address _flpToken) external;\\n}\\n\",\"keccak256\":\"0xa533e69b48a4816db0e03fbd23eb39bad5ab23e762602a326619fb92cb94a774\",\"license\":\"BUSL-1.1\"},\"contracts/interfaces/IFlashStrategySushiSwapFactory.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\n\\npragma solidity ^0.8.0;\\n\\ninterface IFlashStrategySushiSwapFactory {\\n    error InvalidFee();\\n    error InvalidFeeRecipient();\\n    error FlashStrategySushiSwapCreated();\\n\\n    event UpdateStakeFeeBPS(uint256 fee);\\n    event UpdateFlashStakeFeeBPS(uint256 fee);\\n    event UpdateFeeRecipient(address feeRecipient);\\n    event CreateFlashStrategySushiSwap(uint256 pid, address strategy);\\n\\n    function flashProtocol() external view returns (address);\\n\\n    function flpTokenFactory() external view returns (address);\\n\\n    function feeRecipient() external view returns (address);\\n\\n    function getFlashStrategySushiSwap(uint256 pid) external view returns (address);\\n\\n    function predictFlashStrategySushiSwapAddress(uint256 pid) external view returns (address strategy);\\n\\n    function updateFeeRecipient(address _feeRecipient) external;\\n\\n    function createFlashStrategySushiSwap(uint256 pid) external returns (address strategy);\\n}\\n\",\"keccak256\":\"0xfa2ca9ab0537cf4b0cf915100d292d48201e905162c4ace0d552d3e5c1cec3f1\",\"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": {
      "feeRecipient()": {
        "notice": "fee recipient"
      },
      "flashProtocol()": {
        "notice": "address of FlashProtocol"
      },
      "flpTokenFactory()": {
        "notice": "address of FarmingLPTokenFactory"
      }
    },
    "version": 1
  },
  "storageLayout": {
    "storage": [
      {
        "astId": 7,
        "contract": "contracts/FlashStrategySushiSwapFactory.sol:FlashStrategySushiSwapFactory",
        "label": "_owner",
        "offset": 0,
        "slot": "0",
        "type": "t_address"
      },
      {
        "astId": 13381,
        "contract": "contracts/FlashStrategySushiSwapFactory.sol:FlashStrategySushiSwapFactory",
        "label": "feeRecipient",
        "offset": 0,
        "slot": "1",
        "type": "t_address"
      },
      {
        "astId": 13386,
        "contract": "contracts/FlashStrategySushiSwapFactory.sol:FlashStrategySushiSwapFactory",
        "label": "getFlashStrategySushiSwap",
        "offset": 0,
        "slot": "2",
        "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"
      }
    }
  }
}