Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IAccessControl
•    - function hasRole(bytes32 role, addres ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _msgSender()
•    - function _msgData()
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function supportsInterface(bytes4 int ...
•    - function hasRole(bytes32 role, addres ...
•    - function _checkRole(bytes32 role)
•    - function _checkRole(bytes32 role, add ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _setupRole(bytes32 role, add ...
•    - function _setRoleAdmin(bytes32 role, ...
•    - function _grantRole(bytes32 role, add ...
•    - function _revokeRole(bytes32 role, ad ...
•    - function paused()
•    - function _requireNotPaused()
•    - function _requirePaused()
•    - function _pause()
•    - function _unpause()
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• interface IERC721Receiver
•    - function onERC721Received(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• interface IVault
•    - function withdrawERC721(address nft, ...
•    - function batchWithdrawERC721(address ...
•  contract Escrow is *
•    - function _onlyOwner(address from, uin ...
•    - function updateVault(IVault pool)
•    - function pause()
•    - function unpause()
•    - function deposit(uint256 tokenID)
•    - function withdraw(uint256 tokenID)
•    - function onERC721Received (
•    - function recordLedger(address owner, ...
•    - function EmergencyWithdrawVault (
•    - function EmergencyWithdraw (

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-03-20
*/

// SPDX-License-Identifier: MIT
// Sources flattened with hardhat v2.12.6 https://hardhat.org

// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File @openzeppelin/contracts/security/[email protected]


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


// File contracts/interfaces/IVault.sol


pragma solidity ^0.8.9;

interface IVault {
    
    function withdrawERC721(address nft, address to, uint256 tokenId) external;
    
    function batchWithdrawERC721(address nft, address[] calldata to, uint256[] calldata tokenIds) external;
}


// File contracts/Escrow.sol


pragma solidity ^0.8.9;





contract Escrow is 
    Pausable,
    AccessControl,
    IERC721Receiver
{
    using Address for address;

    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");

    IERC721 public nft;
    IVault public vault;

    // user => tokenID
    mapping(address => uint256 ) public ledger;

    event Deposit(address indexed sender, address indexed from, uint256 tokenID);
    event Withdraw(address indexed sender, address indexed to, uint256 tokenID);

    modifier onlyNFT(address token) {
        require(token.isContract(), "Only CA");
        require(token == address(nft), "nonSupport");
        _;
    }

    modifier whenNotHold(address from) {
        require(ledger[from] == 0, "Already holding");
        _;
    }

    modifier onlyOwner(address from, uint256 tokenID) {
        _onlyOwner(from, tokenID);
        _;
    }

    function _onlyOwner(address from, uint256 tokenID) internal view {
        require(ledger[from] != 0 && ledger[from] == tokenID, "Only Owner");
    }

    constructor(
        address admin,
        address operator,
        IERC721 token
    ) {
        nft = token;
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(OPERATOR_ROLE, operator);
    }

    function updateVault(IVault pool) external onlyRole(OPERATOR_ROLE) {
        vault = pool;
    }

    function pause() public onlyRole(OPERATOR_ROLE) {
        _pause();
    }

    function unpause() public onlyRole(OPERATOR_ROLE) {
        _unpause();
    }

    function deposit(uint256 tokenID) external whenNotPaused() whenNotHold(msg.sender) {
        require(tokenID > 0, "tokenID can not be zero");
        recordLedger(msg.sender, tokenID);
        IERC721(nft).safeTransferFrom(msg.sender, address(vault), tokenID);
        emit Deposit(msg.sender, msg.sender, tokenID);
    }

    function withdraw(uint256 tokenID) external whenNotPaused() onlyOwner(msg.sender, tokenID) {
        recordLedger(msg.sender, 0);
        IVault(vault).withdrawERC721(address(nft), msg.sender, tokenID);
        emit Withdraw(msg.sender, msg.sender, tokenID);
    }

    function onERC721Received (
        address sender,
        address from,
        uint256 tokenID,
        bytes memory
    ) public virtual override whenNotPaused() onlyNFT(msg.sender) whenNotHold(from) returns (bytes4) {
        require(tokenID > 0, "tokenID can not be zero");
        recordLedger(from, tokenID);
        IERC721(nft).safeTransferFrom(address(this), address(vault), tokenID);
        emit Deposit(sender, from, tokenID);
        return this.onERC721Received.selector;
    }

    function recordLedger(address owner, uint256 tokenID) internal {
        ledger[owner] = tokenID;
    }

    function EmergencyWithdrawVault (
        address[] calldata to,
        uint256[] calldata tokenID
    ) onlyRole(DEFAULT_ADMIN_ROLE) external {
        
        require(tokenID.length == to.length, "Array length must equal. ");

        for( uint256 i = 0; i < tokenID.length; i++ ) {
            _onlyOwner(to[i], tokenID[i]);
            recordLedger(to[i], 0);
            emit Withdraw(msg.sender, to[i], tokenID[i]);
        }

        IVault(vault).batchWithdrawERC721(address(nft), to, tokenID);
    }

    function EmergencyWithdraw (
        address token,
        address to,
        uint256[] calldata tokenID
    ) onlyRole(DEFAULT_ADMIN_ROLE) external {
        for (uint256 i = 0; i < tokenID.length; i++) {
            IERC721(token).safeTransferFrom(address(this), to, tokenID[i]);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"operator","type":"address"},{"internalType":"contract IERC721","name":"token","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"tokenID","type":"uint256[]"}],"name":"EmergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"to","type":"address[]"},{"internalType":"uint256[]","name":"tokenID","type":"uint256[]"}],"name":"EmergencyWithdrawVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"ledger","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nft","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenID","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IVault","name":"pool","type":"address"}],"name":"updateVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"contract IVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenID","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

48112:3623:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23802:204;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;23802:204:0;;;;;;;;50268:504;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;2198:33:1;;;2180:52;;2168:2;2153:18;50268:504:0;2036:202:1;25625:131:0;;;;;;:::i;:::-;25699:7;25726:12;;;:6;:12;;;;;;;;:22;;;25625:131;;;;2574:25:1;;;2562:2;2547:18;25625:131:0;2428:177:1;49992:268:0;;;;;;:::i;:::-;;:::i;:::-;;26066:147;;;;;;:::i;:::-;;:::i;27210:218::-;;;;;;:::i;:::-;;:::i;49571:79::-;;;:::i;48305:18::-;;;;;-1:-1:-1;;;;;48305:18:0;;;;;;-1:-1:-1;;;;;3295:32:1;;;3277:51;;3265:2;3250:18;48305::0;3115:219:1;51425:307:0;;;;;;:::i;:::-;;:::i;31150:86::-;31197:4;31221:7;;;31150:86;;50893:524;;;;;;:::i;:::-;;:::i;49488:75::-;;;:::i;24098:147::-;;;;;;:::i;:::-;;:::i;23203:49::-;;23248:4;23203:49;;49658:326;;;;;;:::i;:::-;;:::i;26506:149::-;;;;;;:::i;:::-;;:::i;49382:98::-;;;;;;:::i;:::-;;:::i;48230:66::-;;-1:-1:-1;;;;;;;;;;;48230:66:0;;48330:19;;;;;-1:-1:-1;;;;;48330:19:0;;;48382:42;;;;;;:::i;:::-;;;;;;;;;;;;;;23802:204;23887:4;-1:-1:-1;;;;;;23911:47:0;;-1:-1:-1;;;23911:47:0;;:87;;-1:-1:-1;;;;;;;;;;5951:40:0;;;23962:36;23904:94;23802:204;-1:-1:-1;;23802:204:0:o;50268:504::-;50486:6;30755:19;:17;:19::i;:::-;50447:10:::1;39840:19:::0;;48643:38:::1;;;::::0;-1:-1:-1;;;48643:38:0;;6333:2:1;48643:38:0::1;::::0;::::1;6315:21:1::0;6372:1;6352:18;;;6345:29;-1:-1:-1;;;6390:18:1;;;6383:37;6437:18;;48643:38:0::1;;;;;;;;;48717:3;::::0;-1:-1:-1;;;;;48700:21:0;;::::1;48717:3:::0;::::1;48700:21;48692:44;;;::::0;-1:-1:-1;;;48692:44:0;;6668:2:1;48692:44:0::1;::::0;::::1;6650:21:1::0;6707:2;6687:18;;;6680:30;-1:-1:-1;;;6726:18:1;;;6719:40;6776:18;;48692:44:0::1;6466:334:1::0;48692:44:0::1;-1:-1:-1::0;;;;;48818:12:0;::::2;;::::0;;;:6:::2;:12;::::0;;;;;50471:4;;48818:17;48810:45:::2;;;::::0;-1:-1:-1;;;48810:45:0;;7007:2:1;48810:45:0::2;::::0;::::2;6989:21:1::0;7046:2;7026:18;;;7019:30;-1:-1:-1;;;7065:18:1;;;7058:45;7120:18;;48810:45:0::2;6805:339:1::0;48810:45:0::2;50523:1:::3;50513:7;:11;50505:47;;;::::0;-1:-1:-1;;;50505:47:0;;7351:2:1;50505:47:0::3;::::0;::::3;7333:21:1::0;7390:2;7370:18;;;7363:30;-1:-1:-1;;;7409:18:1;;;7402:53;7472:18;;50505:47:0::3;7149:347:1::0;50505:47:0::3;-1:-1:-1::0;;;;;50854:13:0;;;;;;:6;:13;;;;;:23;;;50609:3:::3;::::0;50654:5:::3;::::0;50601:69:::3;::::0;-1:-1:-1;;;50601:69:0;;-1:-1:-1;;;;;50609:3:0;;::::3;::::0;50601:29:::3;::::0;:69:::3;::::0;50639:4:::3;::::0;50654:5;;::::3;::::0;50662:7;;50601:69:::3;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;50702:4;-1:-1:-1::0;;;;;50686:30:0::3;50694:6;-1:-1:-1::0;;;;;50686:30:0::3;;50708:7;50686:30;;;;2574:25:1::0;;2562:2;2547:18;;2428:177;50686:30:0::3;;;;;;;;-1:-1:-1::0;;;;50734:30:0;50268:504;-1:-1:-1;;;;;;50268:504:0:o;49992:268::-;30755:19;:17;:19::i;:::-;50062:10:::1;50074:7;48944:25;48955:4;48961:7;48944:10;:25::i;:::-;50107:10:::2;50119:1;50854:13:::0;;;:6;:13;;;;;:23;50139:5:::2;::::0;50169:3:::2;::::0;50132:63:::2;::::0;-1:-1:-1;;;50132:63:0;;-1:-1:-1;;;;;50139:5:0;;::::2;::::0;50132:28:::2;::::0;:63:::2;::::0;50169:3;::::2;::::0;50175:10:::2;::::0;50187:7;;50132:63:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;50211:41:0::2;::::0;2574:25:1;;;50232:10:0::2;::::0;-1:-1:-1;50232:10:0;;-1:-1:-1;50211:41:0::2;::::0;2562:2:1;2547:18;50211:41:0::2;;;;;;;30785:1:::1;;49992:268:::0;:::o;26066:147::-;25699:7;25726:12;;;:6;:12;;;;;;;;:22;;23694:16;23705:4;23694:10;:16::i;:::-;26180:25:::1;26191:4;26197:7;26180:10;:25::i;:::-;26066:147:::0;;;:::o;27210:218::-;-1:-1:-1;;;;;27306:23:0;;3912:10;27306:23;27298:83;;;;-1:-1:-1;;;27298:83:0;;8083:2:1;27298:83:0;;;8065:21:1;8122:2;8102:18;;;8095:30;8161:34;8141:18;;;8134:62;-1:-1:-1;;;8212:18:1;;;8205:45;8267:19;;27298:83:0;7881:411:1;27298:83:0;27394:26;27406:4;27412:7;27394:11;:26::i;:::-;27210:218;;:::o;49571:79::-;-1:-1:-1;;;;;;;;;;;23694:16:0;23705:4;23694:10;:16::i;:::-;49632:10:::1;:8;:10::i;:::-;49571:79:::0;:::o;51425:307::-;23248:4;23694:16;23248:4;23694:10;:16::i;:::-;51596:9:::1;51591:134;51611:18:::0;;::::1;51591:134;;;51659:5;-1:-1:-1::0;;;;;51651:31:0::1;;51691:4;51698:2;51702:7;;51710:1;51702:10;;;;;;;:::i;:::-;;;;;;;51651:62;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;51631:3;;;;;:::i;:::-;;;;51591:134;;;;51425:307:::0;;;;;:::o;50893:524::-;23248:4;23694:16;23248:4;23694:10;:16::i;:::-;51069:27;;::::1;51061:65;;;::::0;-1:-1:-1;;;51061:65:0;;8903:2:1;51061:65:0::1;::::0;::::1;8885:21:1::0;8942:2;8922:18;;;8915:30;8981:27;8961:18;;;8954:55;9026:18;;51061:65:0::1;8701:349:1::0;51061:65:0::1;51144:9;51139:198;51159:18:::0;;::::1;51139:198;;;51200:29;51211:2;;51214:1;51211:5;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;51218:7;;51226:1;51218:10;;;;;;;:::i;:::-;;;;;;;51200;:29::i;:::-;51244:22;51257:2;;51260:1;51257:5;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;50854:13:0;51264:1:::1;50854:13:::0;;;:6;:13;;;;;:23;50780:105;51244:22:::1;51307:2;;51310:1;51307:5;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;51286:39:0::1;51295:10;51286:39;51314:7:::0;;51322:1;51314:10;;::::1;;;;;:::i;:::-;;;;;;;51286:39;;;;2574:25:1::0;;2562:2;2547:18;;2428:177;51286:39:0::1;;;;;;;;51179:3:::0;::::1;::::0;::::1;:::i;:::-;;;;51139:198;;;-1:-1:-1::0;51356:5:0::1;::::0;51391:3:::1;::::0;51349:60:::1;::::0;-1:-1:-1;;;51349:60:0;;-1:-1:-1;;;;;51356:5:0;;::::1;::::0;51349:33:::1;::::0;:60:::1;::::0;51391:3;::::1;::::0;51397:2;;;;51401:7;;;;51349:60:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;50893:524:::0;;;;;:::o;49488:75::-;-1:-1:-1;;;;;;;;;;;23694:16:0;23705:4;23694:10;:16::i;:::-;49547:8:::1;:6;:8::i;24098:147::-:0;24184:4;24208:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;24208:29:0;;;;;;;;;;;;;;;24098:147::o;49658:326::-;30755:19;:17;:19::i;:::-;49729:10:::1;48818:12;::::0;;;:6:::1;:12;::::0;;;;;:17;48810:45:::1;;;::::0;-1:-1:-1;;;48810:45:0;;7007:2:1;48810:45:0::1;::::0;::::1;6989:21:1::0;7046:2;7026:18;;;7019:30;-1:-1:-1;;;7065:18:1;;;7058:45;7120:18;;48810:45:0::1;6805:339:1::0;48810:45:0::1;49770:1:::2;49760:7;:11;49752:47;;;::::0;-1:-1:-1;;;49752:47:0;;7351:2:1;49752:47:0::2;::::0;::::2;7333:21:1::0;7390:2;7370:18;;;7363:30;-1:-1:-1;;;7409:18:1;;;7402:53;7472:18;;49752:47:0::2;7149:347:1::0;49752:47:0::2;49823:10;50854:13:::0;;;;:6;:13;;;;;:23;;;49862:3:::2;::::0;49904:5:::2;::::0;49854:66:::2;::::0;-1:-1:-1;;;49854:66:0;;-1:-1:-1;;;;;49862:3:0;;::::2;::::0;49854:29:::2;::::0;:66:::2;::::0;49884:10:::2;::::0;49904:5;;::::2;::::0;49912:7;;49854:66:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;49936:40:0::2;::::0;2574:25:1;;;49956:10:0::2;::::0;-1:-1:-1;49956:10:0;;-1:-1:-1;49936:40:0::2;::::0;2562:2:1;2547:18;49936:40:0::2;;;;;;;30785:1:::1;49658:326:::0;:::o;26506:149::-;25699:7;25726:12;;;:6;:12;;;;;;;;:22;;23694:16;23705:4;23694:10;:16::i;:::-;26621:26:::1;26633:4;26639:7;26621:11;:26::i;49382:98::-:0;-1:-1:-1;;;;;;;;;;;23694:16:0;23705:4;23694:10;:16::i;:::-;-1:-1:-1;49460:5:0::1;:12:::0;;-1:-1:-1;;;;;;49460:12:0::1;-1:-1:-1::0;;;;;49460:12:0;;;::::1;::::0;;;::::1;::::0;;49382:98::o;31309:108::-;31197:4;31221:7;;;31379:9;31371:38;;;;-1:-1:-1;;;31371:38:0;;10411:2:1;31371:38:0;;;10393:21:1;10450:2;10430:18;;;10423:30;-1:-1:-1;;;10469:18:1;;;10462:46;10525:18;;31371:38:0;10209:340:1;31371:38:0;31309:108::o;48997:151::-;-1:-1:-1;;;;;49081:12:0;;;;;;:6;:12;;;;;;:17;;;;:44;;-1:-1:-1;;;;;;49102:12:0;;;;;;:6;:12;;;;;;:23;;49081:44;49073:67;;;;-1:-1:-1;;;49073:67:0;;10756:2:1;49073:67:0;;;10738:21:1;10795:2;10775:18;;;10768:30;-1:-1:-1;;;10814:18:1;;;10807:40;10864:18;;49073:67:0;10554:334:1;24549:105:0;24616:30;24627:4;3912:10;24616;:30::i;28807:238::-;28891:22;28899:4;28905:7;28891;:22::i;:::-;28886:152;;28930:12;;;;28962:4;28930:12;;;;;;;;-1:-1:-1;;;;;28930:29:0;;;;;;;;;;:36;;-1:-1:-1;;28930:36:0;;;;;;;28986:40;;3912:10;;28930:12;;28986:40;;28930:12;28986:40;28807:238;;:::o;29225:239::-;29309:22;29317:4;29323:7;29309;:22::i;:::-;29305:152;;;29380:5;29348:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;29348:29:0;;;;;;;;;;:37;;-1:-1:-1;;29348:37:0;;;29405:40;3912:10;;29348:12;;29405:40;;29380:5;29405:40;29225:239;;:::o;32005:120::-;31014:16;:14;:16::i;:::-;32074:5:::1;32064:15:::0;;-1:-1:-1;;32064:15:0::1;::::0;;32095:22:::1;3912:10:::0;32104:12:::1;32095:22;::::0;-1:-1:-1;;;;;3295:32:1;;;3277:51;;3265:2;3250:18;32095:22:0::1;;;;;;;32005:120::o:0;31746:118::-;30755:19;:17;:19::i;:::-;31806:7:::1;:14:::0;;-1:-1:-1;;31806:14:0::1;31816:4;31806:14;::::0;;31836:20:::1;31843:12;3912:10:::0;;3832:98;24944:492;25033:22;25041:4;25047:7;25033;:22::i;:::-;25028:401;;25221:28;25241:7;25221:19;:28::i;:::-;25322:38;25350:4;25357:2;25322:19;:38::i;:::-;25126:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;25126:257:0;;;;;;;;;;-1:-1:-1;;;25072:345:0;;;;;;;:::i;31494:108::-;31197:4;31221:7;;;31553:41;;;;-1:-1:-1;;;31553:41:0;;12776:2:1;31553:41:0;;;12758:21:1;12815:2;12795:18;;;12788:30;-1:-1:-1;;;12834:18:1;;;12827:50;12894:18;;31553:41:0;12574:344:1;21061:151:0;21119:13;21152:52;-1:-1:-1;;;;;21164:22:0;;19216:2;20457:447;20532:13;20558:19;20590:10;20594:6;20590:1;:10;:::i;:::-;:14;;20603:1;20590:14;:::i;:::-;20580:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20580:25:0;;20558:47;;-1:-1:-1;;;20616:6:0;20623:1;20616:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;20616:15:0;;;;;;;;;-1:-1:-1;;;20642:6:0;20649:1;20642:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;20642:15:0;;;;;;;;-1:-1:-1;20673:9:0;20685:10;20689:6;20685:1;:10;:::i;:::-;:14;;20698:1;20685:14;:::i;:::-;20673:26;;20668:131;20705:1;20701;:5;20668:131;;;-1:-1:-1;;;20749:5:0;20757:3;20749:11;20740:21;;;;;;;:::i;:::-;;;;20728:6;20735:1;20728:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;20728:33:0;;;;;;;;-1:-1:-1;20786:1:0;20776:11;;;;;20708:3;;;:::i;:::-;;;20668:131;;;-1:-1:-1;20817:10:0;;20809:55;;;;-1:-1:-1;;;20809:55:0;;13569:2:1;20809:55:0;;;13551:21:1;;;13588:18;;;13581:30;13647:34;13627:18;;;13620:62;13699:18;;20809:55:0;13367:356:1;20809:55:0;20889:6;20457:447;-1:-1:-1;;;20457:447:0:o;14:286:1:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;497:131;-1:-1:-1;;;;;572:31:1;;562:42;;552:70;;618:1;615;608:12;633:127;694:10;689:3;685:20;682:1;675:31;725:4;722:1;715:15;749:4;746:1;739:15;765:1266;860:6;868;876;884;937:3;925:9;916:7;912:23;908:33;905:53;;;954:1;951;944:12;905:53;993:9;980:23;1012:31;1037:5;1012:31;:::i;:::-;1062:5;-1:-1:-1;1119:2:1;1104:18;;1091:32;1132:33;1091:32;1132:33;:::i;:::-;1184:7;-1:-1:-1;1238:2:1;1223:18;;1210:32;;-1:-1:-1;1293:2:1;1278:18;;1265:32;1316:18;1346:14;;;1343:34;;;1373:1;1370;1363:12;1343:34;1411:6;1400:9;1396:22;1386:32;;1456:7;1449:4;1445:2;1441:13;1437:27;1427:55;;1478:1;1475;1468:12;1427:55;1514:2;1501:16;1536:2;1532;1529:10;1526:36;;;1542:18;;:::i;:::-;1617:2;1611:9;1585:2;1671:13;;-1:-1:-1;;1667:22:1;;;1691:2;1663:31;1659:40;1647:53;;;1715:18;;;1735:22;;;1712:46;1709:72;;;1761:18;;:::i;:::-;1801:10;1797:2;1790:22;1836:2;1828:6;1821:18;1876:7;1871:2;1866;1862;1858:11;1854:20;1851:33;1848:53;;;1897:1;1894;1887:12;1848:53;1953:2;1948;1944;1940:11;1935:2;1927:6;1923:15;1910:46;1998:1;1993:2;1988;1980:6;1976:15;1972:24;1965:35;2019:6;2009:16;;;;;;;765:1266;;;;;;;:::o;2243:180::-;2302:6;2355:2;2343:9;2334:7;2330:23;2326:32;2323:52;;;2371:1;2368;2361:12;2323:52;-1:-1:-1;2394:23:1;;2243:180;-1:-1:-1;2243:180:1:o;2795:315::-;2863:6;2871;2924:2;2912:9;2903:7;2899:23;2895:32;2892:52;;;2940:1;2937;2930:12;2892:52;2976:9;2963:23;2953:33;;3036:2;3025:9;3021:18;3008:32;3049:31;3074:5;3049:31;:::i;:::-;3099:5;3089:15;;;2795:315;;;;;:::o;3339:367::-;3402:8;3412:6;3466:3;3459:4;3451:6;3447:17;3443:27;3433:55;;3484:1;3481;3474:12;3433:55;-1:-1:-1;3507:20:1;;3550:18;3539:30;;3536:50;;;3582:1;3579;3572:12;3536:50;3619:4;3611:6;3607:17;3595:29;;3679:3;3672:4;3662:6;3659:1;3655:14;3647:6;3643:27;3639:38;3636:47;3633:67;;;3696:1;3693;3686:12;3633:67;3339:367;;;;;:::o;3711:713::-;3815:6;3823;3831;3839;3892:2;3880:9;3871:7;3867:23;3863:32;3860:52;;;3908:1;3905;3898:12;3860:52;3947:9;3934:23;3966:31;3991:5;3966:31;:::i;:::-;4016:5;-1:-1:-1;4073:2:1;4058:18;;4045:32;4086:33;4045:32;4086:33;:::i;:::-;4138:7;-1:-1:-1;4196:2:1;4181:18;;4168:32;4223:18;4212:30;;4209:50;;;4255:1;4252;4245:12;4209:50;4294:70;4356:7;4347:6;4336:9;4332:22;4294:70;:::i;:::-;3711:713;;;;-1:-1:-1;4383:8:1;-1:-1:-1;;;;3711:713:1:o;4429:773::-;4551:6;4559;4567;4575;4628:2;4616:9;4607:7;4603:23;4599:32;4596:52;;;4644:1;4641;4634:12;4596:52;4684:9;4671:23;4713:18;4754:2;4746:6;4743:14;4740:34;;;4770:1;4767;4760:12;4740:34;4809:70;4871:7;4862:6;4851:9;4847:22;4809:70;:::i;:::-;4898:8;;-1:-1:-1;4783:96:1;-1:-1:-1;4986:2:1;4971:18;;4958:32;;-1:-1:-1;5002:16:1;;;4999:36;;;5031:1;5028;5021:12;4999:36;;5070:72;5134:7;5123:8;5112:9;5108:24;5070:72;:::i;5207:262::-;5281:6;5334:2;5322:9;5313:7;5309:23;5305:32;5302:52;;;5350:1;5347;5340:12;5302:52;5389:9;5376:23;5408:31;5433:5;5408:31;:::i;7501:375::-;-1:-1:-1;;;;;7759:15:1;;;7741:34;;7811:15;;;;7806:2;7791:18;;7784:43;7858:2;7843:18;;7836:34;;;;7691:2;7676:18;;7501:375::o;8297:127::-;8358:10;8353:3;8349:20;8346:1;8339:31;8389:4;8386:1;8379:15;8413:4;8410:1;8403:15;8429:127;8490:10;8485:3;8481:20;8478:1;8471:31;8521:4;8518:1;8511:15;8545:4;8542:1;8535:15;8561:135;8600:3;8621:17;;;8618:43;;8641:18;;:::i;:::-;-1:-1:-1;8688:1:1;8677:13;;8561:135::o;9055:1149::-;-1:-1:-1;;;;;9439:15:1;;;9421:34;;9371:2;9474;9492:18;;;9485:30;;;9356:18;;;9550:22;;;9323:4;;9630:6;;9603:3;9588:19;;9323:4;9664:260;9678:6;9675:1;9672:13;9664:260;;;9753:6;9740:20;9773:31;9798:5;9773:31;:::i;:::-;9829:14;;9817:27;;9899:15;;;;9864:12;;;;9700:1;9693:9;9664:260;;;-1:-1:-1;9960:19:1;;;9955:2;9940:18;;9933:47;9989:19;;;-1:-1:-1;;;;;10020:31:1;;10017:51;;;10064:1;10061;10054:12;10017:51;10098:6;10095:1;10091:14;10077:28;;10149:6;10141;10136:2;10131:3;10127:12;10114:42;10177:16;;;10173:25;;;;9055:1149;-1:-1:-1;;;;;;;;9055:1149:1:o;11101:250::-;11186:1;11196:113;11210:6;11207:1;11204:13;11196:113;;;11286:11;;;11280:18;11267:11;;;11260:39;11232:2;11225:10;11196:113;;;-1:-1:-1;;11343:1:1;11325:16;;11318:27;11101:250::o;11356:812::-;11767:25;11762:3;11755:38;11737:3;11822:6;11816:13;11838:75;11906:6;11901:2;11896:3;11892:12;11885:4;11877:6;11873:17;11838:75;:::i;:::-;-1:-1:-1;;;11972:2:1;11932:16;;;11964:11;;;11957:40;12022:13;;12044:76;12022:13;12106:2;12098:11;;12091:4;12079:17;;12044:76;:::i;:::-;12140:17;12159:2;12136:26;;11356:812;-1:-1:-1;;;;11356:812:1:o;12173:396::-;12322:2;12311:9;12304:21;12285:4;12354:6;12348:13;12397:6;12392:2;12381:9;12377:18;12370:34;12413:79;12485:6;12480:2;12469:9;12465:18;12460:2;12452:6;12448:15;12413:79;:::i;:::-;12553:2;12532:15;-1:-1:-1;;12528:29:1;12513:45;;;;12560:2;12509:54;;12173:396;-1:-1:-1;;12173:396:1:o;12923:168::-;12996:9;;;13027;;13044:15;;;13038:22;;13024:37;13014:71;;13065:18;;:::i;13096:125::-;13161:9;;;13182:10;;;13179:36;;;13195:18;;:::i;13226:136::-;13265:3;13293:5;13283:39;;13302:18;;:::i;:::-;-1:-1:-1;;;13338:18:1;;13226:136::o

ipfs://bd4f8419191200fd8eb7b2eb60a5a9da9d2eb5c6569c212b53c470dfd51cbe5a