creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "@openzeppelin/contracts-v4/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"
      },
      "@openzeppelin/contracts-v4/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"
      },
      "@openzeppelin/contracts-v4/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"
      },
      "@openzeppelin/contracts-v4/token/ERC20/utils/SafeERC20.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.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"
      },
      "@openzeppelin/contracts-v4/token/ERC721/IERC721.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes calldata data\n    ) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the caller.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool _approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"
      },
      "@openzeppelin/contracts-v4/utils/Address.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.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 functionCall(target, data, \"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        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(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        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(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        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason 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            // 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}\n"
      },
      "@openzeppelin/contracts-v4/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"
      },
      "@openzeppelin/contracts-v4/utils/introspection/IERC165.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"
      },
      "contracts/external/cover/CoverBroker.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity ^0.8.18;\n\nimport \"@openzeppelin/contracts-v4/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts-v4/token/ERC20/utils/SafeERC20.sol\";\nimport \"@openzeppelin/contracts-v4/access/Ownable.sol\";\n\nimport \"../../interfaces/ICover.sol\";\nimport \"../../interfaces/ICoverBroker.sol\";\nimport \"../../interfaces/IMemberRoles.sol\";\nimport \"../../interfaces/INXMMaster.sol\";\nimport \"../../interfaces/INXMToken.sol\";\nimport \"../../interfaces/IPool.sol\";\n\n/// @title Cover Broker Contract\n/// @notice Enables non-members of the mutual to purchase cover policies.\n/// Supports payments in ETH and pool supported ERC20 assets.\n/// For NXM payments by members, please call Cover.buyCover instead.\n/// @dev See supported ERC20 asset payments via pool.getAssets.\ncontract CoverBroker is ICoverBroker, Ownable {\n  using SafeERC20 for IERC20;\n\n  // Immutables\n  ICover public immutable cover;\n  IMemberRoles public immutable memberRoles;\n  INXMToken public immutable nxmToken;\n  INXMMaster public immutable master;\n\n  // Constants\n  address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n  uint private constant ETH_ASSET_ID = 0;\n  uint private constant NXM_ASSET_ID = type(uint8).max;\n\n  constructor(\n    address _cover,\n    address _memberRoles,\n    address _nxmToken,\n    address _master,\n    address _owner\n  ) {\n    cover = ICover(_cover);\n    memberRoles = IMemberRoles(_memberRoles);\n    nxmToken = INXMToken(_nxmToken);\n    master = INXMMaster(_master);\n    transferOwnership(_owner);\n  }\n\n  /// @notice Buys cover on behalf of the caller. Supports payments in ETH and pool supported ERC20 assets.\n  /// @dev For ERC20 payments, ensure the Cover contract is approved to spend the tokens first (maxApproveCoverContract).\n  /// See supported ERC20 asset payments via pool.getAssets.\n  /// @param params The parameters required to buy cover.\n  /// @param poolAllocationRequests The allocation requests for the pool's liquidity.\n  /// @return coverId The ID of the purchased cover.\n  function buyCover(\n    BuyCoverParams calldata params,\n    PoolAllocationRequest[] calldata poolAllocationRequests\n  ) external payable returns (uint coverId) {\n\n    if (params.owner == address(0) || params.owner == address(this)) {\n      revert InvalidOwnerAddress();\n    }\n\n    if (params.paymentAsset == NXM_ASSET_ID) {\n      revert InvalidPaymentAsset();\n    }\n\n    // ETH payment\n    if (params.paymentAsset == ETH_ASSET_ID) {\n      return _buyCoverEthPayment(params, poolAllocationRequests);\n    }\n\n    // msg.value must be 0 if not an ETH payment\n    if (msg.value > 0) {\n      revert InvalidPayment();\n    }\n\n    // ERC20 payment\n    return _buyCoverErc20Payment(params, poolAllocationRequests);\n  }\n\n  /// @notice Handles ETH payments for buying cover.\n  /// @dev Calculates ETH refunds if applicable and sends back to msg.sender.\n  /// @param params The parameters required to buy cover.\n  /// @param poolAllocationRequests The allocation requests for the pool's liquidity.\n  /// @return coverId The ID of the purchased cover.\n  function _buyCoverEthPayment(\n    BuyCoverParams calldata params,\n    PoolAllocationRequest[] calldata poolAllocationRequests\n  ) internal returns (uint coverId) {\n\n    uint ethBalanceBefore = address(this).balance - msg.value;\n    coverId = cover.buyCover{value: msg.value}(params, poolAllocationRequests);\n    uint ethBalanceAfter = address(this).balance;\n\n    // transfer any ETH refund back to msg.sender\n    if (ethBalanceAfter > ethBalanceBefore) {\n      uint ethRefund = ethBalanceAfter - ethBalanceBefore;\n      (bool sent,) = payable(msg.sender).call{value: ethRefund}(\"\");\n      if (!sent) {\n        revert TransferFailed(msg.sender, ethRefund, ETH);\n      }\n    }\n  }\n\n  /// @notice Handles ERC20 payments for buying cover.\n  /// @dev Transfers ERC20 tokens from the caller to the contract, then buys cover on behalf of the caller.\n  /// Calculates ERC20 refunds if any and sends back to msg.sender.\n  /// @param params The parameters required to buy cover.\n  /// @param poolAllocationRequests The allocation requests for the pool's liquidity.\n  /// @return coverId The ID of the purchased cover.\n  function _buyCoverErc20Payment(\n    BuyCoverParams calldata params,\n    PoolAllocationRequest[] calldata poolAllocationRequests\n  ) internal returns (uint coverId) {\n\n    address paymentAsset = _pool().getAsset(params.paymentAsset).assetAddress;\n    IERC20 erc20 = IERC20(paymentAsset);\n\n    uint erc20BalanceBefore = erc20.balanceOf(address(this));\n\n    erc20.safeTransferFrom(msg.sender, address(this), params.maxPremiumInAsset);\n    coverId = cover.buyCover(params, poolAllocationRequests);\n\n    uint erc20BalanceAfter = erc20.balanceOf(address(this));\n\n    // send any ERC20 refund back to msg.sender\n    if (erc20BalanceAfter > erc20BalanceBefore) {\n      uint erc20Refund = erc20BalanceAfter - erc20BalanceBefore;\n      erc20.safeTransfer(msg.sender, erc20Refund);\n    }\n  }\n\n  /// @notice Allows the Cover contract to spend the maximum possible amount of a specified ERC20 token on behalf of the CoverBroker.\n  /// @param erc20 The ERC20 token for which to approve spending.\n  function maxApproveCoverContract(IERC20 erc20) external onlyOwner {\n    erc20.safeApprove(address(cover), type(uint256).max);\n  }\n\n  /// @notice Switches CoverBroker's membership to a new address.\n  /// @dev MemberRoles contract needs to be approved to transfer NXM tokens to new membership address.\n  /// @param newAddress The address to which the membership will be switched.\n  function switchMembership(address newAddress) external onlyOwner {\n    nxmToken.approve(address(memberRoles), type(uint256).max);\n    memberRoles.switchMembership(newAddress);\n  }\n\n  /// @notice Recovers all available funds of a specified asset (ETH or ERC20) to the contract owner.\n  /// @param assetAddress The address of the asset to be rescued.\n  function rescueFunds(address assetAddress) external onlyOwner {\n\n    if (assetAddress == ETH) {\n      uint ethBalance = address(this).balance;\n      if (ethBalance == 0) {\n        revert ZeroBalance(ETH);\n      }\n\n      (bool sent,) = payable(msg.sender).call{value: ethBalance}(\"\");\n      if (!sent) {\n        revert TransferFailed(msg.sender, ethBalance, ETH);\n      }\n\n      return;\n    }\n\n    IERC20 asset = IERC20(assetAddress);\n    uint erc20Balance = asset.balanceOf(address(this));\n    if (erc20Balance == 0) {\n      revert ZeroBalance(assetAddress);\n    }\n\n    asset.transfer(msg.sender, erc20Balance);\n  }\n\n  /* ========== DEPENDENCIES ========== */\n\n  /// @dev Fetches the Pool's instance through master contract\n  /// @return The Pool's instance\n  function _pool() internal view returns (IPool) {\n    return IPool(master.getLatestAddress(\"P1\"));\n  }\n\n  receive() external payable {}\n}\n"
      },
      "contracts/interfaces/ICover.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\nimport \"./ICoverNFT.sol\";\nimport \"./IStakingNFT.sol\";\nimport \"./IStakingPool.sol\";\nimport \"./IStakingPoolFactory.sol\";\n\n/* ========== DATA STRUCTURES ========== */\n\nenum ClaimMethod {\n  IndividualClaims,\n  YieldTokenIncidents\n}\n\n// Basically CoverStatus from QuotationData.sol but with the extra Migrated status to avoid\n// polluting Cover.sol state layout with new status variables.\nenum LegacyCoverStatus {\n  Active,\n  ClaimAccepted,\n  ClaimDenied,\n  CoverExpired,\n  ClaimSubmitted,\n  Requested,\n  Migrated\n}\n\n/* io structs */\n\nstruct PoolAllocationRequest {\n  uint40 poolId;\n  bool skip;\n  uint coverAmountInAsset;\n}\n\nstruct RequestAllocationVariables {\n  uint previousPoolAllocationsLength;\n  uint previousPremiumInNXM;\n  uint refund;\n  uint coverAmountInNXM;\n}\n\nstruct BuyCoverParams {\n  uint coverId;\n  address owner;\n  uint24 productId;\n  uint8 coverAsset;\n  uint96 amount;\n  uint32 period;\n  uint maxPremiumInAsset;\n  uint8 paymentAsset;\n  uint16 commissionRatio;\n  address commissionDestination;\n  string ipfsData;\n}\n\nstruct ProductParam {\n  string productName;\n  uint productId;\n  string ipfsMetadata;\n  Product product;\n  uint[] allowedPools;\n}\n\nstruct ProductTypeParam {\n  string productTypeName;\n  uint productTypeId;\n  string ipfsMetadata;\n  ProductType productType;\n}\n\nstruct ProductInitializationParams {\n  uint productId;\n  uint8 weight;\n  uint96 initialPrice;\n  uint96 targetPrice;\n}\n\n/* storage structs */\n\nstruct PoolAllocation {\n  uint40 poolId;\n  uint96 coverAmountInNXM;\n  uint96 premiumInNXM;\n  uint24 allocationId;\n}\n\nstruct CoverData {\n  uint24 productId;\n  uint8 coverAsset;\n  uint96 amountPaidOut;\n}\n\nstruct CoverSegment {\n  uint96 amount;\n  uint32 start;\n  uint32 period; // seconds\n  uint32 gracePeriod; // seconds\n  uint24 globalRewardsRatio;\n  uint24 globalCapacityRatio;\n}\n\nstruct Product {\n  uint16 productType;\n  address yieldTokenAddress;\n  // cover assets bitmap. each bit represents whether the asset with\n  // the index of that bit is enabled as a cover asset for this product\n  uint32 coverAssets;\n  uint16 initialPriceRatio;\n  uint16 capacityReductionRatio;\n  bool isDeprecated;\n  bool useFixedPrice;\n}\n\nstruct ProductType {\n  uint8 claimMethod;\n  uint32 gracePeriod;\n}\n\nstruct ActiveCover {\n  // Global active cover amount per asset.\n  uint192 totalActiveCoverInAsset;\n  // The last time activeCoverExpirationBuckets was updated\n  uint64 lastBucketUpdateId;\n}\n\ninterface ICover {\n\n  /* ========== VIEWS ========== */\n\n  function coverData(uint coverId) external view returns (CoverData memory);\n\n  function coverDataCount() external view returns (uint);\n\n  function coverSegmentsCount(uint coverId) external view returns (uint);\n\n  function coverSegments(uint coverId) external view returns (CoverSegment[] memory);\n\n  function coverSegmentWithRemainingAmount(\n    uint coverId,\n    uint segmentId\n  ) external view returns (CoverSegment memory);\n\n  function products(uint id) external view returns (Product memory);\n\n  function productTypes(uint id) external view returns (ProductType memory);\n\n  function stakingPool(uint index) external view returns (IStakingPool);\n\n  function productNames(uint productId) external view returns (string memory);\n\n  function productsCount() external view returns (uint);\n\n  function productTypesCount() external view returns (uint);\n\n  function totalActiveCoverInAsset(uint coverAsset) external view returns (uint);\n\n  function globalCapacityRatio() external view returns (uint);\n\n  function globalRewardsRatio() external view returns (uint);\n\n  function getPriceAndCapacityRatios(uint[] calldata productIds) external view returns (\n    uint _globalCapacityRatio,\n    uint _globalMinPriceRatio,\n    uint[] memory _initialPriceRatios,\n    uint[] memory _capacityReductionRatios\n  );\n\n  /* === MUTATIVE FUNCTIONS ==== */\n\n  function addLegacyCover(\n    uint productId,\n    uint coverAsset,\n    uint amount,\n    uint start,\n    uint period,\n    address newOwner\n  ) external returns (uint coverId);\n\n  function buyCover(\n    BuyCoverParams calldata params,\n    PoolAllocationRequest[] calldata coverChunkRequests\n  ) external payable returns (uint coverId);\n\n  function setProductTypes(ProductTypeParam[] calldata productTypes) external;\n\n  function setProducts(ProductParam[] calldata params) external;\n\n  function burnStake(\n    uint coverId,\n    uint segmentId,\n    uint amount\n  ) external returns (address coverOwner);\n\n  function coverNFT() external returns (ICoverNFT);\n\n  function stakingNFT() external returns (IStakingNFT);\n\n  function stakingPoolFactory() external returns (IStakingPoolFactory);\n\n  function createStakingPool(\n    bool isPrivatePool,\n    uint initialPoolFee,\n    uint maxPoolFee,\n    ProductInitializationParams[] calldata productInitParams,\n    string calldata ipfsDescriptionHash\n  ) external returns (uint poolId, address stakingPoolAddress);\n\n  function isPoolAllowed(uint productId, uint poolId) external returns (bool);\n  function requirePoolIsAllowed(uint[] calldata productIds, uint poolId) external view;\n\n  /* ========== EVENTS ========== */\n\n  event ProductSet(uint id, string ipfsMetadata);\n  event ProductTypeSet(uint id, string ipfsMetadata);\n  event CoverEdited(uint indexed coverId, uint indexed productId, uint indexed segmentId, address buyer, string ipfsMetadata);\n\n  // Auth\n  error OnlyMemberRolesCanOperateTransfer();\n  error OnlyOwnerOrApproved();\n\n  // Cover details\n  error CoverPeriodTooShort();\n  error CoverPeriodTooLong();\n  error CoverOutsideOfTheGracePeriod();\n  error CoverAmountIsZero();\n\n  // Products\n  error ProductDoesntExist();\n  error ProductTypeNotFound();\n  error ProductDoesntExistOrIsDeprecated();\n  error InvalidProductType();\n  error UnexpectedProductId();\n  error PoolNotAllowedForThisProduct(uint productId);\n\n  // Cover and payment assets\n  error CoverAssetNotSupported();\n  error InvalidPaymentAsset();\n  error UnexpectedCoverAsset();\n  error UnsupportedCoverAssets();\n  error UnexpectedEthSent();\n  error EditNotSupported();\n\n  // Price & Commission\n  error PriceExceedsMaxPremiumInAsset();\n  error TargetPriceBelowGlobalMinPriceRatio();\n  error InitialPriceRatioBelowGlobalMinPriceRatio();\n  error InitialPriceRatioAbove100Percent();\n  error CommissionRateTooHigh();\n\n  // ETH transfers\n  error InsufficientEthSent();\n  error SendingEthToPoolFailed();\n  error SendingEthToCommissionDestinationFailed();\n  error ReturningEthRemainderToSenderFailed();\n\n  // Misc\n  error AlreadyInitialized();\n  error ExpiredCoversCannotBeEdited();\n  error CoverNotYetExpired(uint coverId);\n  error CoverAlreadyExpired(uint coverId);\n  error InsufficientCoverAmountAllocated();\n  error UnexpectedPoolId();\n  error CapacityReductionRatioAbove100Percent();\n}\n"
      },
      "contracts/interfaces/ICoverBroker.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity ^0.8.18;\n\nimport \"@openzeppelin/contracts-v4/token/ERC20/IERC20.sol\";\n\nimport \"../interfaces/ICover.sol\";\n\ninterface ICoverBroker {\n\n  /* ==== FUNCTIONS ==== */\n\n  function buyCover(\n    BuyCoverParams calldata params,\n    PoolAllocationRequest[] calldata poolAllocationRequests\n  ) external payable returns (uint coverId);\n\n  function maxApproveCoverContract(IERC20 token) external;\n\n  function switchMembership(address newAddress) external;\n\n  function rescueFunds(address assetAddress) external;\n\n  /* ==== ERRORS ==== */\n\n  error TransferFailed(address to, uint value, address token);\n  error ZeroBalance(address token);\n  error InvalidOwnerAddress();\n  error InvalidPaymentAsset();\n  error InvalidPayment();\n}\n"
      },
      "contracts/interfaces/ICoverNFT.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\nimport \"@openzeppelin/contracts-v4/token/ERC721/IERC721.sol\";\n\ninterface ICoverNFT is IERC721 {\n\n  function isApprovedOrOwner(address spender, uint tokenId) external returns (bool);\n\n  function mint(address to) external returns (uint tokenId);\n\n  function changeOperator(address newOperator) external;\n\n  function totalSupply() external view returns (uint);\n\n  function name() external view returns (string memory);\n\n  error NotOperator();\n  error NotMinted();\n  error WrongFrom();\n  error InvalidRecipient();\n  error InvalidNewOperatorAddress();\n  error InvalidNewNFTDescriptorAddress();\n  error NotAuthorized();\n  error UnsafeRecipient();\n  error AlreadyMinted();\n\n}\n"
      },
      "contracts/interfaces/IMemberRoles.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\ninterface IMemberRoles {\n\n  enum Role {Unassigned, AdvisoryBoard, Member, Owner}\n\n  function join(address _userAddress, uint nonce, bytes calldata signature) external payable;\n\n  function switchMembership(address _newAddress) external;\n\n  function switchMembershipAndAssets(\n    address newAddress,\n    uint[] calldata coverIds,\n    uint[] calldata stakingTokenIds\n  ) external;\n\n  function switchMembershipOf(address member, address _newAddress) external;\n\n  function totalRoles() external view returns (uint256);\n\n  function changeAuthorized(uint _roleId, address _newAuthorized) external;\n\n  function setKycAuthAddress(address _add) external;\n\n  function members(uint _memberRoleId) external view returns (uint, address[] memory memberArray);\n\n  function numberOfMembers(uint _memberRoleId) external view returns (uint);\n\n  function authorized(uint _memberRoleId) external view returns (address);\n\n  function roles(address _memberAddress) external view returns (uint[] memory);\n\n  function checkRole(address _memberAddress, uint _roleId) external view returns (bool);\n\n  function getMemberLengthForAllRoles() external view returns (uint[] memory totalMembers);\n\n  function memberAtIndex(uint _memberRoleId, uint index) external view returns (address, bool);\n\n  function membersLength(uint _memberRoleId) external view returns (uint);\n\n  event MemberRole(uint256 indexed roleId, bytes32 roleName, string roleDescription);\n\n  event MemberJoined(address indexed newMember, uint indexed nonce);\n\n  event switchedMembership(address indexed previousMember, address indexed newMember, uint timeStamp);\n  \n  event MembershipWithdrawn(address indexed member, uint timestamp);\n}\n"
      },
      "contracts/interfaces/INXMMaster.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\ninterface INXMMaster {\n\n  function tokenAddress() external view returns (address);\n\n  function owner() external view returns (address);\n\n  function emergencyAdmin() external view returns (address);\n\n  function masterInitialized() external view returns (bool);\n\n  function isInternal(address _add) external view returns (bool);\n\n  function isPause() external view returns (bool check);\n\n  function isMember(address _add) external view returns (bool);\n\n  function checkIsAuthToGoverned(address _add) external view returns (bool);\n\n  function getLatestAddress(bytes2 _contractName) external view returns (address payable contractAddress);\n\n  function contractAddresses(bytes2 code) external view returns (address payable);\n\n  function upgradeMultipleContracts(\n    bytes2[] calldata _contractCodes,\n    address payable[] calldata newAddresses\n  ) external;\n\n  function removeContracts(bytes2[] calldata contractCodesToRemove) external;\n\n  function addNewInternalContracts(\n    bytes2[] calldata _contractCodes,\n    address payable[] calldata newAddresses,\n    uint[] calldata _types\n  ) external;\n\n  function updateOwnerParameters(bytes8 code, address payable val) external;\n}\n"
      },
      "contracts/interfaces/INXMToken.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\ninterface INXMToken {\n\n  function burn(uint256 amount) external returns (bool);\n\n  function burnFrom(address from, uint256 value) external returns (bool);\n\n  function operatorTransfer(address from, uint256 value) external returns (bool);\n\n  function mint(address account, uint256 amount) external;\n\n  function isLockedForMV(address member) external view returns (uint);\n\n  function whiteListed(address member) external view returns (bool);\n\n  function addToWhiteList(address _member) external returns (bool);\n\n  function removeFromWhiteList(address _member) external returns (bool);\n\n  function changeOperator(address _newOperator) external returns (bool);\n\n  function lockForMemberVote(address _of, uint _days) external;\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 `recipient`.\n   *\n   * Returns a boolean value indicating whether the operation succeeded.\n   *\n   * Emits a {Transfer} event.\n   */\n  function transfer(address recipient, 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 `sender` to `recipient` using the\n   * allowance mechanism. `amount` is then deducted from the caller's\n   * allowance.\n   *\n   * Returns a boolean value indicating whether the operation succeeded.\n   *\n   * Emits a {Transfer} event.\n   */\n  function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n  /**\n   * @dev Emitted when `value` tokens are moved from one account (`from`) to\n   * another (`to`).\n   *\n   * Note that `value` may be zero.\n   */\n  event Transfer(address indexed from, address indexed to, uint256 value);\n\n  /**\n   * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n   * a call to {approve}. `value` is the new allowance.\n   */\n  event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
      },
      "contracts/interfaces/IPool.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\nimport \"./IPriceFeedOracle.sol\";\n\nstruct SwapDetails {\n  uint104 minAmount;\n  uint104 maxAmount;\n  uint32 lastSwapTime;\n  // 2 decimals of precision. 0.01% -> 0.0001 -> 1e14\n  uint16 maxSlippageRatio;\n}\n\nstruct Asset {\n  address assetAddress;\n  bool isCoverAsset;\n  bool isAbandoned;\n}\n\ninterface IPool {\n\n  function getAsset(uint assetId) external view returns (Asset memory);\n\n  function getAssets() external view returns (Asset[] memory);\n\n  function transferAssetToSwapOperator(address asset, uint amount) external;\n\n  function setSwapDetailsLastSwapTime(address asset, uint32 lastSwapTime) external;\n\n  function getAssetSwapDetails(address assetAddress) external view returns (SwapDetails memory);\n\n  function sendPayout(uint assetIndex, address payable payoutAddress, uint amount, uint ethDepositAmount) external;\n\n  function sendEth(address payoutAddress, uint amount) external;\n\n  function upgradeCapitalPool(address payable newPoolAddress) external;\n\n  function priceFeedOracle() external view returns (IPriceFeedOracle);\n\n  function getPoolValueInEth() external view returns (uint);\n\n  function calculateMCRRatio(uint totalAssetValue, uint mcrEth) external pure returns (uint);\n\n  function getInternalTokenPriceInAsset(uint assetId) external view returns (uint tokenPrice);\n\n  function getInternalTokenPriceInAssetAndUpdateTwap(uint assetId) external returns (uint tokenPrice);\n\n  function getTokenPrice() external view returns (uint tokenPrice);\n\n  function getMCRRatio() external view returns (uint);\n\n  function setSwapValue(uint value) external;\n}\n"
      },
      "contracts/interfaces/IPriceFeedOracle.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\ninterface Aggregator {\n  function latestAnswer() external view returns (int);\n}\n\nstruct OracleAsset {\n  Aggregator aggregator;\n  uint8 decimals;\n}\n\ninterface IPriceFeedOracle {\n\n  function ETH() external view returns (address);\n  function assets(address) external view returns (Aggregator, uint8);\n\n  function getAssetToEthRate(address asset) external view returns (uint);\n  function getAssetForEth(address asset, uint ethIn) external view returns (uint);\n  function getEthForAsset(address asset, uint amount) external view returns (uint);\n\n}\n"
      },
      "contracts/interfaces/IStakingNFT.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\nimport \"@openzeppelin/contracts-v4/token/ERC721/IERC721.sol\";\n\ninterface IStakingNFT is IERC721 {\n\n  function isApprovedOrOwner(address spender, uint tokenId) external returns (bool);\n\n  function mint(uint poolId, address to) external returns (uint tokenId);\n\n  function changeOperator(address newOperator) external;\n\n  function totalSupply() external returns (uint);\n\n  function tokenInfo(uint tokenId) external view returns (uint poolId, address owner);\n\n  function stakingPoolOf(uint tokenId) external view returns (uint poolId);\n\n  function stakingPoolFactory() external view returns (address);\n\n  function name() external view returns (string memory);\n\n  error NotOperator();\n  error NotMinted();\n  error WrongFrom();\n  error InvalidRecipient();\n  error InvalidNewOperatorAddress();\n  error InvalidNewNFTDescriptorAddress();\n  error NotAuthorized();\n  error UnsafeRecipient();\n  error AlreadyMinted();\n  error NotStakingPool();\n\n}\n"
      },
      "contracts/interfaces/IStakingPool.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\n/* structs for io */\n\nstruct AllocationRequest {\n  uint productId;\n  uint coverId;\n  uint allocationId;\n  uint period;\n  uint gracePeriod;\n  bool useFixedPrice;\n  uint previousStart;\n  uint previousExpiration;\n  uint previousRewardsRatio;\n  uint globalCapacityRatio;\n  uint capacityReductionRatio;\n  uint rewardRatio;\n  uint globalMinPrice;\n}\n\nstruct StakedProductParam {\n  uint productId;\n  bool recalculateEffectiveWeight;\n  bool setTargetWeight;\n  uint8 targetWeight;\n  bool setTargetPrice;\n  uint96 targetPrice;\n}\n\n  struct BurnStakeParams {\n    uint allocationId;\n    uint productId;\n    uint start;\n    uint period;\n    uint deallocationAmount;\n  }\n\ninterface IStakingPool {\n\n  /* structs for storage */\n\n  // stakers are grouped in tranches based on the timelock expiration\n  // tranche index is calculated based on the expiration date\n  // the initial proposal is to have 4 tranches per year (1 tranche per quarter)\n  struct Tranche {\n    uint128 stakeShares;\n    uint128 rewardsShares;\n  }\n\n  struct ExpiredTranche {\n    uint96 accNxmPerRewardShareAtExpiry;\n    uint96 stakeAmountAtExpiry; // nxm total supply is 6.7e24 and uint96.max is 7.9e28\n    uint128 stakeSharesSupplyAtExpiry;\n  }\n\n  struct Deposit {\n    uint96 lastAccNxmPerRewardShare;\n    uint96 pendingRewards;\n    uint128 stakeShares;\n    uint128 rewardsShares;\n  }\n\n  function initialize(\n    bool isPrivatePool,\n    uint initialPoolFee,\n    uint maxPoolFee,\n    uint _poolId,\n    string memory ipfsDescriptionHash\n  ) external;\n\n  function processExpirations(bool updateUntilCurrentTimestamp) external;\n\n  function requestAllocation(\n    uint amount,\n    uint previousPremium,\n    AllocationRequest calldata request\n  ) external returns (uint premium, uint allocationId);\n\n  function burnStake(uint amount, BurnStakeParams calldata params) external;\n\n  function depositTo(\n    uint amount,\n    uint trancheId,\n    uint requestTokenId,\n    address destination\n  ) external returns (uint tokenId);\n\n  function withdraw(\n    uint tokenId,\n    bool withdrawStake,\n    bool withdrawRewards,\n    uint[] memory trancheIds\n  ) external returns (uint withdrawnStake, uint withdrawnRewards);\n\n  function isPrivatePool() external view returns (bool);\n\n  function isHalted() external view returns (bool);\n\n  function manager() external view returns (address);\n\n  function getPoolId() external view returns (uint);\n\n  function getPoolFee() external view returns (uint);\n\n  function getMaxPoolFee() external view returns (uint);\n\n  function getActiveStake() external view returns (uint);\n\n  function getStakeSharesSupply() external view returns (uint);\n\n  function getRewardsSharesSupply() external view returns (uint);\n\n  function getRewardPerSecond() external view returns (uint);\n\n  function getAccNxmPerRewardsShare() external view returns (uint);\n\n  function getLastAccNxmUpdate() external view returns (uint);\n\n  function getFirstActiveTrancheId() external view returns (uint);\n\n  function getFirstActiveBucketId() external view returns (uint);\n\n  function getNextAllocationId() external view returns (uint);\n\n  function getDeposit(uint tokenId, uint trancheId) external view returns (\n    uint lastAccNxmPerRewardShare,\n    uint pendingRewards,\n    uint stakeShares,\n    uint rewardsShares\n  );\n\n  function getTranche(uint trancheId) external view returns (\n    uint stakeShares,\n    uint rewardsShares\n  );\n\n  function getExpiredTranche(uint trancheId) external view returns (\n    uint accNxmPerRewardShareAtExpiry,\n    uint stakeAmountAtExpiry,\n    uint stakeShareSupplyAtExpiry\n  );\n\n  function setPoolFee(uint newFee) external;\n\n  function setPoolPrivacy(bool isPrivatePool) external;\n\n  function getActiveAllocations(\n    uint productId\n  ) external view returns (uint[] memory trancheAllocations);\n\n  function getTrancheCapacities(\n    uint productId,\n    uint firstTrancheId,\n    uint trancheCount,\n    uint capacityRatio,\n    uint reductionRatio\n  ) external view returns (uint[] memory trancheCapacities);\n\n  /* ========== EVENTS ========== */\n\n  event StakeDeposited(address indexed user, uint256 amount, uint256 trancheId, uint256 tokenId);\n\n  event DepositExtended(address indexed user, uint256 tokenId, uint256 initialTrancheId, uint256 newTrancheId, uint256 topUpAmount);\n\n  event PoolPrivacyChanged(address indexed manager, bool isPrivate);\n\n  event PoolFeeChanged(address indexed manager, uint newFee);\n\n  event PoolDescriptionSet(string ipfsDescriptionHash);\n\n  event Withdraw(address indexed user, uint indexed tokenId, uint tranche, uint amountStakeWithdrawn, uint amountRewardsWithdrawn);\n\n  event StakeBurned(uint amount);\n\n  event Deallocated(uint productId);\n\n  event BucketExpired(uint bucketId);\n\n  event TrancheExpired(uint trancheId);\n\n  // Auth\n  error OnlyCoverContract();\n  error OnlyManager();\n  error PrivatePool();\n  error SystemPaused();\n  error PoolHalted();\n\n  // Fees\n  error PoolFeeExceedsMax();\n  error MaxPoolFeeAbove100();\n\n  // Voting\n  error NxmIsLockedForGovernanceVote();\n  error ManagerNxmIsLockedForGovernanceVote();\n\n  // Deposit\n  error InsufficientDepositAmount();\n  error RewardRatioTooHigh();\n\n  // Staking NFTs\n  error InvalidTokenId();\n  error NotTokenOwnerOrApproved();\n  error InvalidStakingPoolForToken();\n\n  // Tranche & capacity\n  error NewTrancheEndsBeforeInitialTranche();\n  error RequestedTrancheIsNotYetActive();\n  error RequestedTrancheIsExpired();\n  error InsufficientCapacity();\n\n  // Allocation\n  error AlreadyDeallocated(uint allocationId);\n}\n"
      },
      "contracts/interfaces/IStakingPoolFactory.sol": {
        "content": "// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity >=0.5.0;\n\ninterface IStakingPoolFactory {\n\n  function stakingPoolCount() external view returns (uint);\n\n  function beacon() external view returns (address);\n\n  function create(address beacon) external returns (uint poolId, address stakingPoolAddress);\n\n  event StakingPoolCreated(uint indexed poolId, address indexed stakingPoolAddress);\n}\n"
      }
    },
    "settings": {
      "optimizer": {
        "enabled": true,
        "runs": 200
      },
      "outputSelection": {
        "*": {
          "*": [
            "evm.bytecode",
            "evm.deployedBytecode",
            "devdoc",
            "userdoc",
            "metadata",
            "abi"
          ]
        }
      },
      "libraries": {}
    }
  }}