Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2024-01-10
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// 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/ERC165.sol


// 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/SignedMath.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.9.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) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 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 256, 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 << 3) < value ? 1 : 0);
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.9.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 `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @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);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// 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/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/access/IAccessControl.sol


// 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/access/AccessControl.sol


// OpenZeppelin Contracts (last updated v4.9.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:
 *
 * ```solidity
 * 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}:
 *
 * ```solidity
 * 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. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
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/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// File: Interface/IMetaX.sol


pragma solidity ^0.8.18;

interface IMetaX {

/** Token Vault **/
    function Release () external;

/** PlanetMan **/
    function getRarity (uint256 _tokenId) external view returns (uint256);

    function getAllTokens (address owner) external view returns (uint256[] memory);

/** XPower **/
    function getLevel (uint256 tokenId) external view returns (uint256 level);

    function getLevelCom (uint256 tokenId) external view returns (uint256 level);

/** PlanetBadges **/
    function getBoostNum (address user) external view returns (uint256);

/** POSW **/
    function setEpoch () external;

    function getEpoch () external view returns (uint256);

    function addPOSW (address user, uint256 posw) external;

    function getPOSW (address user) external view returns (uint256);

/** Staking **/
  /* Staking Level */
    function Level (address user) external view returns (uint256 level);

    function baseScores (address user) external view returns (uint256 _baseScores);

    function Adjustment (address user) external view returns (uint256 adjustment);

    function finalScores (address user) external view returns (uint256);

  /* Planet Vault */
    function getStakedAmount (address user) external view returns (uint256);

    function getAccumStakedAmount (address user) external view returns (uint256);

    function getStakedAmount_Record_All (address user) external view returns (uint256[] memory);

    function getStakedTime_Record_All (address user) external view returns (uint256[] memory);

/** Algorithm **/
    function bestPM (address user) external view returns (uint256);

    function syncPMRate (address user) external view returns (uint256 rate);

    function stakeRate (address user) external view returns (uint256);

    function getRate (address user) external view returns (uint256 rate);

/** Red Pocket **/
    function getAccumSend (address user) external view returns (uint256);

    function getAccumSendByUser (address user0, address user1) external view returns (uint256);

    function getEpochSendByUser (address user0, address user1, uint256 epoch) external view returns (uint256);

    function getCurrentSendByUser (address user0, address user1) external view returns (uint256);
}
// File: SocialMining_V2/SocialMiningV2.sol


pragma solidity ^0.8.18;







contract SocialMiningV2 is AccessControl, Ownable {
    using SafeMath for uint256;

/** Roles **/
    bytes32 public constant Admin = keccak256("Admin");

/** Events **/
    event releaseRecord (uint256 Epoch, uint256 release_SM, uint256 release_BI, uint256 time);
    event merkleRootRecord (uint256 Epoch, bytes32[] merkleRoot, uint256 time);
    event claimRecord (address user, uint256 token, uint256 posw, uint256 time);
    event burnRecord (uint256 epoch, uint256 burnAmount, uint256 time);

/** Initialization **/
    constructor () {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(Admin, msg.sender);
    }

/** Smart Contracts Preset **/
    /* $MetaX */
    address public MetaX = 0xdc1B3F63944e0ff11dbaD513FE4175fc0466cE2E;
    IERC20 public MX = IERC20(MetaX);

    /* SocialMining Vault */
    IMetaX public SMV = IMetaX(0x923708845Bdd7CaCC2754735A4DE584314B12caf);

    /* Builder Incentives Vault */
    IMetaX public BIV = IMetaX(0xFD80fD0Fc8540BA036a8477aB4491402a0e076A0);

    /* POSW */
    IMetaX public POSW = IMetaX(0xAdE8D4f355926805e5cDc8277d9c71AD10324E47);

/** Epoch Release **/
    function Release (uint256[] memory batch, bytes32[] memory _merkleRoot) public onlyRole(Admin) {
        require(block.timestamp > Epoch().add(epoch), "SocialMiningV2: Still within the current epoch.");
        if (Balance() > 0) {
            Burn();
        }
        setRoot(batch, _merkleRoot);
        release();
        POSW.setEpoch();
        emit releaseRecord (Epoch(), maxRelease_SM, maxRelease_BI, block.timestamp);
    }

    function release () public onlyRole(Admin) {
        require(block.timestamp > Epoch().add(epoch), "SocialMiningV2: Still within the current epoch.");
        for (uint256 i=0; i<epochInDays; i++) {
            SMV.Release();
            BIV.Release();
        }
    }

    /** Max Release by Epoch **/
    uint256 public T0 = 1676505600; /* Genesis Epoch @Feb 16th 2023 */
    uint256 public epoch = 7 days;
    uint256 public epochInDays = 7;

    function Epoch() public view returns (uint256) {
        return POSW.getEpoch();
    }

    uint256 public maxRelease_SM = 38356164 ether; /* 40% allocation | halve every 2 years | released in epoch */
    uint256 public maxRelease_BI =  4794517 ether; /*  5% allocation | halve every 2 years | released in epoch */

    function Halve() public onlyOwner {
        require(block.timestamp >= T0.add(730 days), "SocialMiningV2: Please wait till next halve.");
        maxRelease_SM = maxRelease_SM.div(2);
        maxRelease_BI = maxRelease_BI.div(2);
        T0 = T0.add(730 days);
    }

/** $MetaX Claiming **/
    mapping (address => uint256) public recentClaimed;

    function getRecentClaimed (address user) public view returns (uint256) {
        return recentClaimed[user];
    }

    /* Verification */
    mapping (uint256 => bytes32) public merkleRoot;

    function setRoot (uint256[] memory batch, bytes32[] memory _merkleRoot) public onlyRole(Admin) {
        for (uint256 i=0; i<batch.length; i++) {
            merkleRoot[batch[i]] = _merkleRoot[i];
        }
        emit merkleRootRecord (Epoch(), _merkleRoot, block.timestamp);
    }

    function verify (uint256 batch, uint256 token, uint256 posw, bytes32[] calldata merkleProof) public view returns (bool) {
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender, token, posw));
        return MerkleProof.verify(merkleProof, merkleRoot[batch], leaf);
    }

    /* Claim */
    function Claim (uint256 batch, uint256 token, uint256 posw, bytes32[] calldata merkleProof) public {
        require(verify(batch, token, posw, merkleProof), "SocialMiningV2: Incorrect POSW & tokens inputs.");
        require(block.timestamp < Epoch().add(epoch), "SocialMiningV2: Claiming process has not started.");
        require(recentClaimed[msg.sender] < Epoch(), "SocialMiningV2: You have claimed your $MetaX of last epoch.");
        MX.transfer(msg.sender, token);
        POSW.addPOSW(msg.sender, posw);
        recentClaimed[msg.sender] = block.timestamp;
        emit claimRecord (msg.sender, token, posw, block.timestamp);
    }

    /* Balance Check */
    function Balance () public view returns (uint256) {
        return MX.balanceOf(address(this));
    }

    /* Burn Unclaim $MetaX */
    address public immutable burnAddr = 0x000000000000000000000000000000000000dEaD;

    function Burn () public onlyRole(Admin) {
        require(block.timestamp > Epoch().add(epoch), "SocialMiningV2: Still within current epoch.");
        require(Balance() > 0, "SocialMiningV2: No unclaimed $MetaX.");
        MX.transfer(burnAddr, Balance());
        emit burnRecord (Epoch(), Balance(), block.timestamp);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":"uint256","name":"epoch","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"burnAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"burnRecord","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"token","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"posw","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"claimRecord","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"Epoch","type":"uint256"},{"indexed":false,"internalType":"bytes32[]","name":"merkleRoot","type":"bytes32[]"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"merkleRootRecord","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"Epoch","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"release_SM","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"release_BI","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"releaseRecord","type":"event"},{"inputs":[],"name":"Admin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BIV","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Balance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"batch","type":"uint256"},{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"posw","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"Claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Epoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Halve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"MX","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MetaX","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POSW","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"batch","type":"uint256[]"},{"internalType":"bytes32[]","name":"_merkleRoot","type":"bytes32[]"}],"name":"Release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"SMV","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochInDays","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getRecentClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"maxRelease_BI","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxRelease_SM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"recentClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":"uint256[]","name":"batch","type":"uint256[]"},{"internalType":"bytes32[]","name":"_merkleRoot","type":"bytes32[]"}],"name":"setRoot","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"batch","type":"uint256"},{"internalType":"uint256","name":"token","type":"uint256"},{"internalType":"uint256","name":"posw","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

56371:4823:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28599:204;;;;;;:::i;:::-;;:::i;:::-;;;516:14:1;;509:22;491:41;;479:2;464:18;28599:204:0;;;;;;;;57541:442;;;;;;:::i;:::-;;:::i;:::-;;60631:103;;;:::i;:::-;;;3158:25:1;;;3146:2;3131:18;60631:103:0;3012:177:1;30422:131:0;;;;;;:::i;:::-;30496:7;30523:12;;;;;;;;;;:22;;;;30422:131;30863:147;;;;;;:::i;:::-;;:::i;58665:45::-;;;;;;32007:218;;;;;;:::i;:::-;;:::i;60860:331::-;;;:::i;59292:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;57343:70;;;;;-1:-1:-1;;;;;57343:70:0;;;;;;-1:-1:-1;;;;;4385:55:1;;;4367:74;;4355:2;4340:18;57343:70:0;4206:241:1;58307:30:0;;;;;;59144:116;;;;;;:::i;:::-;-1:-1:-1;;;;;59233:19:0;59206:7;59233:19;;;:13;:19;;;;;;;59144:116;58454:88;;;:::i;22037:103::-;;;:::i;57991:274::-;;;:::i;59643:280::-;;;;;;:::i;:::-;;:::i;59347:288::-;;;;;;:::i;:::-;;:::i;21396:87::-;21469:6;;-1:-1:-1;;;;;21469:6:0;21396:87;;58379:29;;;;;;28895:147;;;;;;:::i;:::-;28981:4;29005:12;;;;;;;;;;;-1:-1:-1;;;;;29005:29:0;;;;;;;;;;;;;;;28895:147;57157:32;;;;;-1:-1:-1;;;;;57157:32:0;;;28000:49;;28045:4;28000:49;;58550:45;;;;;;59948:650;;;;;;:::i;:::-;;:::i;57228:70::-;;;;;-1:-1:-1;;;;;57228:70:0;;;57085:65;;;;;-1:-1:-1;;;;;57085:65:0;;;59086:49;;;;;;:::i;:::-;;;;;;;;;;;;;;60773:78;;;;;58782:271;;;:::i;31303:149::-;;;;;;:::i;:::-;;:::i;22295:201::-;;;;;;:::i;:::-;;:::i;58415:30::-;;;;;;57438:71;;;;;-1:-1:-1;;;;;57438:71:0;;;56478:50;;56510:18;56478:50;;28599:204;28684:4;-1:-1:-1;;;;;;28708:47:0;;28723:32;28708:47;;:87;;-1:-1:-1;1906:25:0;-1:-1:-1;;;;;;1891:40:0;;;28759:36;28701:94;28599:204;-1:-1:-1;;28599:204:0:o;57541:442::-;56510:18;28491:16;28502:4;28491:10;:16::i;:::-;57673:18:::1;57685:5;;57673:7;:5;:7::i;:::-;:11:::0;::::1;:18::i;:::-;57655:15;:36;57647:96;;;::::0;-1:-1:-1;;;57647:96:0;;6147:2:1;57647:96:0::1;::::0;::::1;6129:21:1::0;6186:2;6166:18;;;6159:30;6225:34;6205:18;;;6198:62;6296:17;6276:18;;;6269:45;6331:19;;57647:96:0::1;;;;;;;;;57770:1;57758:9;:7;:9::i;:::-;:13;57754:52;;;57788:6;:4;:6::i;:::-;57816:27;57824:5;57831:11;57816:7;:27::i;:::-;57854:9;:7;:9::i;:::-;57874:4;;;;;;;;;-1:-1:-1::0;;;;;57874:4:0::1;-1:-1:-1::0;;;;;57874:13:0::1;;:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57905:70;57920:7;:5;:7::i;:::-;57929:13;::::0;57944::::1;::::0;57905:70:::1;::::0;;6592:25:1;;;6648:2;6633:18;;6626:34;;;;6676:18;;;6669:34;57959:15:0::1;6734:2:1::0;6719:18;;6712:34;6579:3;6564:19;57905:70:0::1;;;;;;;;57541:442:::0;;;:::o;60631:103::-;60699:2;;:27;;;;;60720:4;60699:27;;;4367:74:1;60672:7:0;;-1:-1:-1;;;;;60699:2:0;;:12;;4340:18:1;;60699:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60692:34;;60631:103;:::o;30863:147::-;30496:7;30523:12;;;;;;;;;;:22;;;28491:16;28502:4;28491:10;:16::i;:::-;30977:25:::1;30988:4;30994:7;30977:10;:25::i;:::-;30863:147:::0;;;:::o;32007:218::-;-1:-1:-1;;;;;32103:23:0;;20027:10;32103:23;32095:83;;;;-1:-1:-1;;;32095:83:0;;7148:2:1;32095:83:0;;;7130:21:1;7187:2;7167:18;;;7160:30;7226:34;7206:18;;;7199:62;7297:17;7277:18;;;7270:45;7332:19;;32095:83:0;6946:411:1;32095:83:0;32191:26;32203:4;32209:7;32191:11;:26::i;:::-;32007:218;;:::o;60860:331::-;56510:18;28491:16;28502:4;28491:10;:16::i;:::-;60937:18:::1;60949:5;;60937:7;:5;:7::i;:18::-;60919:15;:36;60911:92;;;::::0;-1:-1:-1;;;60911:92:0;;7564:2:1;60911:92:0::1;::::0;::::1;7546:21:1::0;7603:2;7583:18;;;7576:30;7642:34;7622:18;;;7615:62;7713:13;7693:18;;;7686:41;7744:19;;60911:92:0::1;7362:407:1::0;60911:92:0::1;61034:1;61022:9;:7;:9::i;:::-;:13;61014:62;;;::::0;-1:-1:-1;;;61014:62:0;;7976:2:1;61014:62:0::1;::::0;::::1;7958:21:1::0;8015:2;7995:18;;;7988:30;8054:34;8034:18;;;8027:62;8125:6;8105:18;;;8098:34;8149:19;;61014:62:0::1;7774:400:1::0;61014:62:0::1;61087:2;::::0;-1:-1:-1;;;;;61087:2:0::1;:11;61099:8;61109:9;:7;:9::i;:::-;61087:32;::::0;-1:-1:-1;;;;;;61087:32:0::1;::::0;;;;;;-1:-1:-1;;;;;8371:55:1;;;61087:32:0::1;::::0;::::1;8353:74:1::0;8443:18;;;8436:34;8326:18;;61087:32:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;61135:48;61147:7;:5;:7::i;:::-;61156:9;:7;:9::i;:::-;61135:48;::::0;;8965:25:1;;;9021:2;9006:18;;8999:34;;;;61167:15:0::1;9049:18:1::0;;;9042:34;8953:2;8938:18;61135:48:0::1;;;;;;;60860:331:::0;:::o;58454:88::-;58519:4;;:15;;;;;;;;58492:7;;-1:-1:-1;;;;;58519:4:0;;:13;;:15;;;;;;;;;;;;;;:4;:15;;;;;;;;;;;;;;22037:103;21282:13;:11;:13::i;:::-;22102:30:::1;22129:1;22102:18;:30::i;:::-;22037:103::o:0;57991:274::-;56510:18;28491:16;28502:4;28491:10;:16::i;:::-;58071:18:::1;58083:5;;58071:7;:5;:7::i;:18::-;58053:15;:36;58045:96;;;::::0;-1:-1:-1;;;58045:96:0;;6147:2:1;58045:96:0::1;::::0;::::1;6129:21:1::0;6186:2;6166:18;;;6159:30;6225:34;6205:18;;;6198:62;6296:17;6276:18;;;6269:45;6331:19;;58045:96:0::1;5945:411:1::0;58045:96:0::1;58157:9;58152:106;58172:11;;58170:1;:13;58152:106;;;58205:3;::::0;;:13:::1;::::0;;;;;;;-1:-1:-1;;;;;58205:3:0;;::::1;::::0;:11:::1;::::0;:13;;::::1;::::0;:3:::1;::::0;:13;;;;;;:3;;:13;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;58233:3;;;;;;;;;-1:-1:-1::0;;;;;58233:3:0::1;-1:-1:-1::0;;;;;58233:11:0::1;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;58185:3;;;;;:::i;:::-;;;;58152:106;;59643:280:::0;59799:41;;-1:-1:-1;;59816:10:0;9621:2:1;9617:15;9613:53;59799:41:0;;;9601:66:1;9683:12;;;9676:28;;;9720:12;;;9713:28;;;59757:4:0;;;;9757:12:1;;59799:41:0;;;;;;;;;;;;59789:52;;;;;;59774:67;;59859:56;59878:11;;59859:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59891:17:0;;;:10;:17;;;;;;;-1:-1:-1;59910:4:0;;-1:-1:-1;59859:18:0;;-1:-1:-1;59859:56:0:i;:::-;59852:63;59643:280;-1:-1:-1;;;;;;;59643:280:0:o;59347:288::-;56510:18;28491:16;28502:4;28491:10;:16::i;:::-;59458:9:::1;59453:103;59473:5;:12;59471:1;:14;59453:103;;;59530:11;59542:1;59530:14;;;;;;;;:::i;:::-;;;;;;;59507:10;:20;59518:5;59524:1;59518:8;;;;;;;;:::i;:::-;;;;;;;59507:20;;;;;;;;;;;:37;;;;59487:3;;;;;:::i;:::-;;;;59453:103;;;;59571:56;59589:7;:5;:7::i;:::-;59598:11;59611:15;59571:56;;;;;;;;:::i;59948:650::-:0;60066:39;60073:5;60080;60087:4;60093:11;;60066:6;:39::i;:::-;60058:99;;;;-1:-1:-1;;;60058:99:0;;10951:2:1;60058:99:0;;;10933:21:1;10990:2;10970:18;;;10963:30;11029:34;11009:18;;;11002:62;11100:17;11080:18;;;11073:45;11135:19;;60058:99:0;10749:411:1;60058:99:0;60194:18;60206:5;;60194:7;:5;:7::i;:18::-;60176:15;:36;60168:98;;;;-1:-1:-1;;;60168:98:0;;11367:2:1;60168:98:0;;;11349:21:1;11406:2;11386:18;;;11379:30;11445:34;11425:18;;;11418:62;11516:19;11496:18;;;11489:47;11553:19;;60168:98:0;11165:413:1;60168:98:0;60313:7;:5;:7::i;:::-;60299:10;60285:25;;;;:13;:25;;;;;;:35;60277:107;;;;-1:-1:-1;;;60277:107:0;;11785:2:1;60277:107:0;;;11767:21:1;11824:2;11804:18;;;11797:30;11863:34;11843:18;;;11836:62;11934:29;11914:18;;;11907:57;11981:19;;60277:107:0;11583:423:1;60277:107:0;60395:2;;:30;;;;;60407:10;60395:30;;;8353:74:1;8443:18;;;8436:34;;;-1:-1:-1;;;;;60395:2:0;;;;:11;;8326:18:1;;60395:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;60436:4:0;;:30;;;;;60449:10;60436:30;;;8353:74:1;8443:18;;;8436:34;;;-1:-1:-1;;;;;60436:4:0;;;;:12;;8326:18:1;;60436:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;60491:10:0;60477:25;;;;:13;:25;;;;;;;;;60505:15;60477:43;;;;60536:54;;12242:74:1;;;12332:18;;;12325:34;;;12375:18;;;12368:34;;;12433:2;12418:18;;12411:34;60536:54:0;;;-1:-1:-1;60536:54:0;;;;12229:3:1;60536:54:0;;-1:-1:-1;60536:54:0;59948:650;;;;;:::o;58782:271::-;21282:13;:11;:13::i;:::-;58854:2:::1;::::0;:16:::1;::::0;58861:8:::1;58854:6;:16::i;:::-;58835:15;:35;;58827:92;;;::::0;-1:-1:-1;;;58827:92:0;;12658:2:1;58827:92:0::1;::::0;::::1;12640:21:1::0;12697:2;12677:18;;;12670:30;12736:34;12716:18;;;12709:62;12807:14;12787:18;;;12780:42;12839:19;;58827:92:0::1;12456:408:1::0;58827:92:0::1;58946:13;::::0;:20:::1;::::0;58964:1:::1;58946:17;:20::i;:::-;58930:13;:36:::0;58993:13:::1;::::0;:20:::1;::::0;59011:1:::1;58993:17;:20::i;:::-;58977:13;:36:::0;59029:2:::1;::::0;:16:::1;::::0;59036:8:::1;59029:6;:16::i;:::-;59024:2;:21:::0;58782:271::o;31303:149::-;30496:7;30523:12;;;;;;;;;;:22;;;28491:16;28502:4;28491:10;:16::i;:::-;31418:26:::1;31430:4;31436:7;31418:11;:26::i;22295:201::-:0;21282:13;:11;:13::i;:::-;-1:-1:-1;;;;;22384:22:0;::::1;22376:73;;;::::0;-1:-1:-1;;;22376:73:0;;13071:2:1;22376:73:0::1;::::0;::::1;13053:21:1::0;13110:2;13090:18;;;13083:30;13149:34;13129:18;;;13122:62;13220:8;13200:18;;;13193:36;13246:19;;22376:73:0::1;12869:402:1::0;22376:73:0::1;22460:28;22479:8;22460:18;:28::i;:::-;22295:201:::0;:::o;29346:105::-;29413:30;29424:4;20027:10;29413;:30::i;47035:98::-;47093:7;47120:5;47124:1;47120;:5;:::i;:::-;47113:12;47035:98;-1:-1:-1;;;47035:98:0:o;33604:238::-;28981:4;29005:12;;;;;;;;;;;-1:-1:-1;;;;;29005:29:0;;;;;;;;;;;;33683:152;;33727:6;:12;;;;;;;;;;;-1:-1:-1;;;;;33727:29:0;;;;;;;;;:36;;-1:-1:-1;;33727:36:0;33759:4;33727:36;;;33810:12;20027:10;;19947:98;33810:12;-1:-1:-1;;;;;33783:40:0;33801:7;-1:-1:-1;;;;;33783:40:0;33795:4;33783:40;;;;;;;;;;33604:238;;:::o;34022:239::-;28981:4;29005:12;;;;;;;;;;;-1:-1:-1;;;;;29005:29:0;;;;;;;;;;;;34102:152;;;34177:5;34145:12;;;;;;;;;;;-1:-1:-1;;;;;34145:29:0;;;;;;;;;;:37;;-1:-1:-1;;34145:37:0;;;34202:40;20027:10;;34145:12;;34202:40;;34177:5;34202:40;34022:239;;:::o;21561:132::-;21469:6;;-1:-1:-1;;;;;21469:6:0;20027:10;21625:23;21617:68;;;;-1:-1:-1;;;21617:68:0;;13608:2:1;21617:68:0;;;13590:21:1;;;13627:18;;;13620:30;13686:34;13666:18;;;13659:62;13738:18;;21617:68:0;13406:356:1;22656:191:0;22749:6;;;-1:-1:-1;;;;;22766:17:0;;;;;;;;;;;22799:40;;22749:6;;;22766:17;22749:6;;22799:40;;22730:16;;22799:40;22719:128;22656:191;:::o;35490:156::-;35581:4;35634;35605:25;35618:5;35625:4;35605:12;:25::i;:::-;:33;;35490:156;-1:-1:-1;;;;35490:156:0:o;48172:98::-;48230:7;48257:5;48261:1;48257;:5;:::i;29741:492::-;28981:4;29005:12;;;;;;;;;;;-1:-1:-1;;;;;29005:29:0;;;;;;;;;;;;29825:401;;30018:28;30038:7;30018:19;:28::i;:::-;30119:38;30147:4;30154:2;30119:19;:38::i;:::-;29923:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;29923:257:0;;;;;;;;;;-1:-1:-1;;;29869:345:0;;;;;;;:::i;36289:296::-;36372:7;36415:4;36372:7;36430:118;36454:5;:12;36450:1;:16;36430:118;;;36503:33;36513:12;36527:5;36533:1;36527:8;;;;;;;;:::i;:::-;;;;;;;36503:9;:33::i;:::-;36488:48;-1:-1:-1;36468:3:0;;;;:::i;:::-;;;;36430:118;;;-1:-1:-1;36565:12:0;36289:296;-1:-1:-1;;;36289:296:0:o;18882:151::-;18940:13;18973:52;-1:-1:-1;;;;;18985:22:0;;16757:2;18278:447;18353:13;18379:19;18411:10;18415:6;18411:1;:10;:::i;:::-;:14;;18424:1;18411:14;:::i;:::-;18401:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18401:25:0;;18379:47;;18437:15;:6;18444:1;18437:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18437:15:0;;;;;;;;;18463;:6;18470:1;18463:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18463:15:0;;;;;;;;-1:-1:-1;18494:9:0;18506:10;18510:6;18506:1;:10;:::i;:::-;:14;;18519:1;18506:14;:::i;:::-;18494:26;;18489:131;18526:1;18522;:5;18489:131;;;18561:8;18570:5;18578:3;18570:11;18561:21;;;;;;;:::i;:::-;;;;18549:6;18556:1;18549:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;18549:33:0;;;;;;;;-1:-1:-1;18607:1:0;18597:11;;;;;18529:3;;;:::i;:::-;;;18489:131;;;-1:-1:-1;18638:10:0;;18630:55;;;;-1:-1:-1;;;18630:55:0;;16035:2:1;18630:55:0;;;16017:21:1;;;16054:18;;;16047:30;16113:34;16093:18;;;16086:62;16165:18;;18630:55:0;15833:356:1;43727:149:0;43790:7;43821:1;43817;:5;:51;;43952:13;44046:15;;;44082:4;44075:15;;;44129:4;44113:21;;43817:51;;;43952:13;44046:15;;;44082:4;44075:15;;;44129:4;44113:21;;43825:20;43884:268;14:332:1;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;180:9;167:23;-1:-1:-1;;;;;;223:5:1;219:78;212:5;209:89;199:117;;312:1;309;302:12;543:184;-1:-1:-1;;;592:1:1;585:88;692:4;689:1;682:15;716:4;713:1;706:15;732:275;803:2;797:9;868:2;849:13;;-1:-1:-1;;845:27:1;833:40;;903:18;888:34;;924:22;;;885:62;882:88;;;950:18;;:::i;:::-;986:2;979:22;732:275;;-1:-1:-1;732:275:1:o;1012:183::-;1072:4;1105:18;1097:6;1094:30;1091:56;;;1127:18;;:::i;:::-;-1:-1:-1;1172:1:1;1168:14;1184:4;1164:25;;1012:183::o;1200:662::-;1254:5;1307:3;1300:4;1292:6;1288:17;1284:27;1274:55;;1325:1;1322;1315:12;1274:55;1361:6;1348:20;1387:4;1411:60;1427:43;1467:2;1427:43;:::i;:::-;1411:60;:::i;:::-;1505:15;;;1591:1;1587:10;;;;1575:23;;1571:32;;;1536:12;;;;1615:15;;;1612:35;;;1643:1;1640;1633:12;1612:35;1679:2;1671:6;1667:15;1691:142;1707:6;1702:3;1699:15;1691:142;;;1773:17;;1761:30;;1811:12;;;;1724;;1691:142;;;-1:-1:-1;1851:5:1;1200:662;-1:-1:-1;;;;;;1200:662:1:o;1867:1140::-;1985:6;1993;2046:2;2034:9;2025:7;2021:23;2017:32;2014:52;;;2062:1;2059;2052:12;2014:52;2102:9;2089:23;2131:18;2172:2;2164:6;2161:14;2158:34;;;2188:1;2185;2178:12;2158:34;2226:6;2215:9;2211:22;2201:32;;2271:7;2264:4;2260:2;2256:13;2252:27;2242:55;;2293:1;2290;2283:12;2242:55;2329:2;2316:16;2351:4;2375:60;2391:43;2431:2;2391:43;:::i;2375:60::-;2469:15;;;2551:1;2547:10;;;;2539:19;;2535:28;;;2500:12;;;;2575:19;;;2572:39;;;2607:1;2604;2597:12;2572:39;2631:11;;;;2651:142;2667:6;2662:3;2659:15;2651:142;;;2733:17;;2721:30;;2684:12;;;;2771;;;;2651:142;;;2812:5;-1:-1:-1;;2855:18:1;;2842:32;;-1:-1:-1;;2886:16:1;;;2883:36;;;2915:1;2912;2905:12;2883:36;;2938:63;2993:7;2982:8;2971:9;2967:24;2938:63;:::i;:::-;2928:73;;;1867:1140;;;;;:::o;3194:180::-;3253:6;3306:2;3294:9;3285:7;3281:23;3277:32;3274:52;;;3322:1;3319;3312:12;3274:52;-1:-1:-1;3345:23:1;;3194:180;-1:-1:-1;3194:180:1:o;3561:196::-;3629:20;;-1:-1:-1;;;;;3678:54:1;;3668:65;;3658:93;;3747:1;3744;3737:12;3658:93;3561:196;;;:::o;3762:254::-;3830:6;3838;3891:2;3879:9;3870:7;3866:23;3862:32;3859:52;;;3907:1;3904;3897:12;3859:52;3943:9;3930:23;3920:33;;3972:38;4006:2;3995:9;3991:18;3972:38;:::i;:::-;3962:48;;3762:254;;;;;:::o;4452:186::-;4511:6;4564:2;4552:9;4543:7;4539:23;4535:32;4532:52;;;4580:1;4577;4570:12;4532:52;4603:29;4622:9;4603:29;:::i;4643:820::-;4756:6;4764;4772;4780;4788;4841:3;4829:9;4820:7;4816:23;4812:33;4809:53;;;4858:1;4855;4848:12;4809:53;4894:9;4881:23;4871:33;;4951:2;4940:9;4936:18;4923:32;4913:42;;5002:2;4991:9;4987:18;4974:32;4964:42;;5057:2;5046:9;5042:18;5029:32;5080:18;5121:2;5113:6;5110:14;5107:34;;;5137:1;5134;5127:12;5107:34;5175:6;5164:9;5160:22;5150:32;;5220:7;5213:4;5209:2;5205:13;5201:27;5191:55;;5242:1;5239;5232:12;5191:55;5282:2;5269:16;5308:2;5300:6;5297:14;5294:34;;;5324:1;5321;5314:12;5294:34;5377:7;5372:2;5362:6;5359:1;5355:14;5351:2;5347:23;5343:32;5340:45;5337:65;;;5398:1;5395;5388:12;5337:65;4643:820;;;;-1:-1:-1;4643:820:1;;-1:-1:-1;5429:2:1;5421:11;;5451:6;4643:820;-1:-1:-1;;;4643:820:1:o;6757:184::-;6827:6;6880:2;6868:9;6859:7;6855:23;6851:32;6848:52;;;6896:1;6893;6886:12;6848:52;-1:-1:-1;6919:16:1;;6757:184;-1:-1:-1;6757:184:1:o;8481:277::-;8548:6;8601:2;8589:9;8580:7;8576:23;8572:32;8569:52;;;8617:1;8614;8607:12;8569:52;8649:9;8643:16;8702:5;8695:13;8688:21;8681:5;8678:32;8668:60;;8724:1;8721;8714:12;9087:184;-1:-1:-1;;;9136:1:1;9129:88;9236:4;9233:1;9226:15;9260:4;9257:1;9250:15;9276:135;9315:3;9336:17;;;9333:43;;9356:18;;:::i;:::-;-1:-1:-1;9403:1:1;9392:13;;9276:135::o;9780:184::-;-1:-1:-1;;;9829:1:1;9822:88;9929:4;9926:1;9919:15;9953:4;9950:1;9943:15;9969:775;10167:4;10215:2;10204:9;10200:18;10245:6;10234:9;10227:25;10271:2;10309;10304;10293:9;10289:18;10282:30;10332:6;10367;10361:13;10398:6;10390;10383:22;10436:3;10425:9;10421:19;10414:26;;10475:2;10467:6;10463:15;10449:29;;10496:1;10506:169;10520:6;10517:1;10514:13;10506:169;;;10581:13;;10569:26;;10650:15;;;;10615:12;;;;10542:1;10535:9;10506:169;;;10510:3;;10692;10684:11;;;;;10731:6;10726:2;10715:9;10711:18;10704:34;9969:775;;;;;;:::o;13276:125::-;13341:9;;;13362:10;;;13359:36;;;13375:18;;:::i;13767:274::-;13807:1;13833;13823:189;;-1:-1:-1;;;13865:1:1;13858:88;13969:4;13966:1;13959:15;13997:4;13994:1;13987:15;13823:189;-1:-1:-1;14026:9:1;;13767:274::o;14046:250::-;14131:1;14141:113;14155:6;14152:1;14149:13;14141:113;;;14231:11;;;14225:18;14212:11;;;14205:39;14177:2;14170:10;14141:113;;;-1:-1:-1;;14288:1:1;14270:16;;14263:27;14046:250::o;14301:812::-;14712:25;14707:3;14700:38;14682:3;14767:6;14761:13;14783:75;14851:6;14846:2;14841:3;14837:12;14830:4;14822:6;14818:17;14783:75;:::i;:::-;14922:19;14917:2;14877:16;;;14909:11;;;14902:40;14967:13;;14989:76;14967:13;15051:2;15043:11;;15036:4;15024:17;;14989:76;:::i;:::-;15085:17;15104:2;15081:26;;14301:812;-1:-1:-1;;;;14301:812:1:o;15118:396::-;15267:2;15256:9;15249:21;15230:4;15299:6;15293:13;15342:6;15337:2;15326:9;15322:18;15315:34;15358:79;15430:6;15425:2;15414:9;15410:18;15405:2;15397:6;15393:15;15358:79;:::i;:::-;15498:2;15477:15;-1:-1:-1;;15473:29:1;15458:45;;;;15505:2;15454:54;;15118:396;-1:-1:-1;;15118:396:1:o;15519:168::-;15592:9;;;15623;;15640:15;;;15634:22;;15620:37;15610:71;;15661:18;;:::i;15692:136::-;15731:3;15759:5;15749:39;;15768:18;;:::i;:::-;-1:-1:-1;;;15804:18:1;;15692:136::o

ipfs://3f874b87331e551358e2560501cca1bfb62ed462033437f84580904712a4e2e6