creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "contracts/AuraVestedEscrow.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.11;\n\nimport { IAuraLocker } from \"./Interfaces.sol\";\nimport { IERC20 } from \"@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol\";\nimport { ReentrancyGuard } from \"@openzeppelin/contracts-0.8/security/ReentrancyGuard.sol\";\nimport { AuraMath } from \"./AuraMath.sol\";\n\n/**\n * @title   AuraVestedEscrow\n * @author  adapted from ConvexFinance (convex-platform/contracts/contracts/VestedEscrow)\n * @notice  Vests tokens over a given timeframe to an array of recipients. Allows locking of\n *          these tokens directly to staking contract.\n * @dev     Adaptations:\n *           - One time initialisation\n *           - Consolidation of fundAdmin/admin\n *           - Lock in AuraLocker by default\n *           - Start and end time\n */\ncontract AuraVestedEscrow is ReentrancyGuard {\n    using SafeERC20 for IERC20;\n\n    IERC20 public immutable rewardToken;\n\n    address public admin;\n    address public immutable funder;\n    IAuraLocker public auraLocker;\n\n    uint256 public immutable startTime;\n    uint256 public immutable endTime;\n    uint256 public immutable totalTime;\n\n    bool public initialised = false;\n\n    mapping(address => uint256) public totalLocked;\n    mapping(address => uint256) public totalClaimed;\n\n    event Funded(address indexed recipient, uint256 reward);\n    event Cancelled(address indexed recipient);\n    event Claim(address indexed user, uint256 amount, bool locked);\n\n    /**\n     * @param rewardToken_    Reward token (AURA)\n     * @param admin_          Admin to cancel rewards\n     * @param auraLocker_     Contract where rewardToken can be staked\n     * @param starttime_      Timestamp when claim starts\n     * @param endtime_        When vesting ends\n     */\n    constructor(\n        address rewardToken_,\n        address admin_,\n        address auraLocker_,\n        uint256 starttime_,\n        uint256 endtime_\n    ) {\n        require(starttime_ >= block.timestamp, \"start must be future\");\n        require(endtime_ > starttime_, \"end must be greater\");\n\n        rewardToken = IERC20(rewardToken_);\n        admin = admin_;\n        funder = msg.sender;\n        auraLocker = IAuraLocker(auraLocker_);\n\n        startTime = starttime_;\n        endTime = endtime_;\n        totalTime = endTime - startTime;\n        require(totalTime >= 16 weeks, \"!short\");\n    }\n\n    /***************************************\n                    SETUP\n    ****************************************/\n\n    /**\n     * @notice Change contract admin\n     * @param _admin New admin address\n     */\n    function setAdmin(address _admin) external {\n        require(msg.sender == admin, \"!auth\");\n        admin = _admin;\n    }\n\n    /**\n     * @notice Change locker contract address\n     * @param _auraLocker Aura Locker address\n     */\n    function setLocker(address _auraLocker) external {\n        require(msg.sender == admin, \"!auth\");\n        auraLocker = IAuraLocker(_auraLocker);\n    }\n\n    /**\n     * @notice Fund recipients with rewardTokens\n     * @param _recipient  Array of recipients to vest rewardTokens for\n     * @param _amount     Arrary of amount of rewardTokens to vest\n     */\n    function fund(address[] calldata _recipient, uint256[] calldata _amount) external nonReentrant {\n        require(_recipient.length == _amount.length, \"!arr\");\n        require(!initialised, \"initialised already\");\n        require(msg.sender == funder, \"!funder\");\n        require(block.timestamp < startTime, \"already started\");\n\n        uint256 totalAmount = 0;\n        for (uint256 i = 0; i < _recipient.length; i++) {\n            uint256 amount = _amount[i];\n\n            totalLocked[_recipient[i]] += amount;\n            totalAmount += amount;\n\n            emit Funded(_recipient[i], amount);\n        }\n        rewardToken.safeTransferFrom(msg.sender, address(this), totalAmount);\n        initialised = true;\n    }\n\n    /**\n     * @notice Cancel recipients vesting rewardTokens\n     * @param _recipient Recipient address\n     */\n    function cancel(address _recipient) external nonReentrant {\n        require(msg.sender == admin, \"!auth\");\n        require(totalLocked[_recipient] > 0, \"!funding\");\n\n        _claim(_recipient, false);\n\n        uint256 delta = remaining(_recipient);\n        rewardToken.safeTransfer(admin, delta);\n\n        totalLocked[_recipient] = 0;\n\n        emit Cancelled(_recipient);\n    }\n\n    /***************************************\n                    VIEWS\n    ****************************************/\n\n    /**\n     * @notice Available amount to claim\n     * @param _recipient Recipient to lookup\n     */\n    function available(address _recipient) public view returns (uint256) {\n        uint256 vested = _totalVestedOf(_recipient, block.timestamp);\n        return vested - totalClaimed[_recipient];\n    }\n\n    /**\n     * @notice Total remaining vested amount\n     * @param _recipient Recipient to lookup\n     */\n    function remaining(address _recipient) public view returns (uint256) {\n        uint256 vested = _totalVestedOf(_recipient, block.timestamp);\n        return totalLocked[_recipient] - vested;\n    }\n\n    /**\n     * @notice Get total amount vested for this timestamp\n     * @param _recipient  Recipient to lookup\n     * @param _time       Timestamp to check vesting amount for\n     */\n    function _totalVestedOf(address _recipient, uint256 _time) internal view returns (uint256 total) {\n        if (_time < startTime) {\n            return 0;\n        }\n        uint256 locked = totalLocked[_recipient];\n        uint256 elapsed = _time - startTime;\n        total = AuraMath.min((locked * elapsed) / totalTime, locked);\n    }\n\n    /***************************************\n                    CLAIM\n    ****************************************/\n\n    function claim(bool _lock) external nonReentrant {\n        _claim(msg.sender, _lock);\n    }\n\n    /**\n     * @dev Claim reward token (Aura) and lock it.\n     * @param _recipient  Address to receive rewards.\n     * @param _lock       Lock rewards immediately.\n     */\n    function _claim(address _recipient, bool _lock) internal {\n        uint256 claimable = available(_recipient);\n\n        totalClaimed[_recipient] += claimable;\n\n        if (_lock) {\n            require(address(auraLocker) != address(0), \"!auraLocker\");\n            rewardToken.safeApprove(address(auraLocker), claimable);\n            auraLocker.lock(_recipient, claimable);\n        } else {\n            rewardToken.safeTransfer(_recipient, claimable);\n        }\n\n        emit Claim(_recipient, claimable, _lock);\n    }\n}\n"
      },
      "contracts/Interfaces.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.11;\n\ninterface IPriceOracle {\n    struct OracleAverageQuery {\n        Variable variable;\n        uint256 secs;\n        uint256 ago;\n    }\n    enum Variable {\n        PAIR_PRICE,\n        BPT_PRICE,\n        INVARIANT\n    }\n\n    function getTimeWeightedAverage(OracleAverageQuery[] memory queries)\n        external\n        view\n        returns (uint256[] memory results);\n}\n\ninterface IVault {\n    enum PoolSpecialization {\n        GENERAL,\n        MINIMAL_SWAP_INFO,\n        TWO_TOKEN\n    }\n    enum JoinKind {\n        INIT,\n        EXACT_TOKENS_IN_FOR_BPT_OUT,\n        TOKEN_IN_FOR_EXACT_BPT_OUT,\n        ALL_TOKENS_IN_FOR_EXACT_BPT_OUT\n    }\n\n    enum SwapKind {\n        GIVEN_IN,\n        GIVEN_OUT\n    }\n\n    struct SingleSwap {\n        bytes32 poolId;\n        SwapKind kind;\n        IAsset assetIn;\n        IAsset assetOut;\n        uint256 amount;\n        bytes userData;\n    }\n\n    struct FundManagement {\n        address sender;\n        bool fromInternalBalance;\n        address payable recipient;\n        bool toInternalBalance;\n    }\n\n    struct JoinPoolRequest {\n        IAsset[] assets;\n        uint256[] maxAmountsIn;\n        bytes userData;\n        bool fromInternalBalance;\n    }\n\n    function getPool(bytes32 poolId) external view returns (address, PoolSpecialization);\n\n    function getPoolTokens(bytes32 poolId)\n        external\n        view\n        returns (\n            address[] memory tokens,\n            uint256[] memory balances,\n            uint256 lastChangeBlock\n        );\n\n    function joinPool(\n        bytes32 poolId,\n        address sender,\n        address recipient,\n        JoinPoolRequest memory request\n    ) external payable;\n\n    function swap(\n        SingleSwap memory singleSwap,\n        FundManagement memory funds,\n        uint256 limit,\n        uint256 deadline\n    ) external returns (uint256 amountCalculated);\n\n    function exitPool(\n        bytes32 poolId,\n        address sender,\n        address payable recipient,\n        ExitPoolRequest memory request\n    ) external;\n\n    struct ExitPoolRequest {\n        IAsset[] assets;\n        uint256[] minAmountsOut;\n        bytes userData;\n        bool toInternalBalance;\n    }\n    enum ExitKind {\n        EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,\n        EXACT_BPT_IN_FOR_TOKENS_OUT,\n        BPT_IN_FOR_EXACT_TOKENS_OUT,\n        MANAGEMENT_FEE_TOKENS_OUT // for ManagedPool\n    }\n}\n\ninterface IAsset {\n    // solhint-disable-previous-line no-empty-blocks\n}\n\ninterface IAuraLocker {\n    function lock(address _account, uint256 _amount) external;\n\n    function checkpointEpoch() external;\n\n    function epochCount() external view returns (uint256);\n\n    function balanceAtEpochOf(uint256 _epoch, address _user) external view returns (uint256 amount);\n\n    function totalSupplyAtEpoch(uint256 _epoch) external view returns (uint256 supply);\n\n    function queueNewRewards(address _rewardsToken, uint256 reward) external;\n\n    function getReward(address _account, bool _stake) external;\n\n    function getReward(address _account) external;\n}\n\ninterface IExtraRewardsDistributor {\n    function addReward(address _token, uint256 _amount) external;\n}\n\ninterface ICrvDepositorWrapper {\n    function getMinOut(uint256, uint256) external view returns (uint256);\n\n    function deposit(\n        uint256,\n        uint256,\n        bool,\n        address _stakeAddress\n    ) external;\n}\n"
      },
      "@openzeppelin/contracts-0.8/token/ERC20/IERC20.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (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 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(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) 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"
      },
      "@openzeppelin/contracts-0.8/token/ERC20/utils/SafeERC20.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.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    /**\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-0.8/security/ReentrancyGuard.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (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        // On the first call to nonReentrant, _notEntered will be true\n        require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n        // Any calls to nonReentrant after this point will fail\n        _status = _ENTERED;\n\n        _;\n\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"
      },
      "contracts/AuraMath.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.11;\n\n/// @notice A library for performing overflow-/underflow-safe math,\n/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math).\nlibrary AuraMath {\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {\n        c = a + b;\n    }\n\n    function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {\n        c = a - b;\n    }\n\n    function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {\n        c = a * b;\n    }\n\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a / b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow, so we distribute.\n        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);\n    }\n\n    function to224(uint256 a) internal pure returns (uint224 c) {\n        require(a <= type(uint224).max, \"AuraMath: uint224 Overflow\");\n        c = uint224(a);\n    }\n\n    function to128(uint256 a) internal pure returns (uint128 c) {\n        require(a <= type(uint128).max, \"AuraMath: uint128 Overflow\");\n        c = uint128(a);\n    }\n\n    function to112(uint256 a) internal pure returns (uint112 c) {\n        require(a <= type(uint112).max, \"AuraMath: uint112 Overflow\");\n        c = uint112(a);\n    }\n\n    function to96(uint256 a) internal pure returns (uint96 c) {\n        require(a <= type(uint96).max, \"AuraMath: uint96 Overflow\");\n        c = uint96(a);\n    }\n\n    function to32(uint256 a) internal pure returns (uint32 c) {\n        require(a <= type(uint32).max, \"AuraMath: uint32 Overflow\");\n        c = uint32(a);\n    }\n}\n\n/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint32.\nlibrary AuraMath32 {\n    function sub(uint32 a, uint32 b) internal pure returns (uint32 c) {\n        c = a - b;\n    }\n}\n\n/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint112.\nlibrary AuraMath112 {\n    function add(uint112 a, uint112 b) internal pure returns (uint112 c) {\n        c = a + b;\n    }\n\n    function sub(uint112 a, uint112 b) internal pure returns (uint112 c) {\n        c = a - b;\n    }\n}\n\n/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint224.\nlibrary AuraMath224 {\n    function add(uint224 a, uint224 b) internal pure returns (uint224 c) {\n        c = a + b;\n    }\n}\n"
      },
      "@openzeppelin/contracts-0.8/utils/Address.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)\n\npragma solidity ^0.8.0;\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    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        assembly {\n            size := extcodesize(account)\n        }\n        return size > 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\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"
      }
    },
    "settings": {
      "metadata": {
        "bytecodeHash": "none"
      },
      "optimizer": {
        "enabled": true,
        "runs": 800
      },
      "outputSelection": {
        "*": {
          "*": [
            "evm.bytecode",
            "evm.deployedBytecode",
            "devdoc",
            "userdoc",
            "metadata",
            "abi"
          ]
        }
      },
      "libraries": {}
    }
  }}