Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-04-19
*/

/* SPDX-License-Identifier: MIT */

// Sources flattened with hardhat v2.12.7 https://hardhat.org

// File @openzeppelin/contracts/utils/Context.sol@v4.8.0

// 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@v4.8.0

// OpenZeppelin Contracts (last updated v4.7.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 anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    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/utils/introspection/IERC165.sol@v4.8.0

// 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/token/ERC721/IERC721.sol@v4.8.0

// 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/utils/math/Math.sol@v4.8.0

// 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/Strings.sol@v4.8.0

// 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/utils/cryptography/ECDSA.sol@v4.8.0

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

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File contracts/wasd/WAESUpgrade.sol
pragma solidity ^0.8.18;

contract WAESUpgrade is Ownable {
    using ECDSA for bytes32;

    IERC721 public WAES;
    mapping(address => bool) private _operators;
    mapping(string => bool) private _requestIdUsed;

    event PickaxesBought(
        string requestId,
        uint256 pickaxesPrice,
        uint256[] tokenIds,
        uint256[] extraData
    );

    constructor(address waesAddress) Ownable() {
        WAES = IERC721(waesAddress);
        _operators[msg.sender] = true;
    }

    modifier onlyOperators() {
        require(
            _operators[msg.sender],
            "WAESUpgrade: the caller is not the operator"
        );
        _;
    }

    function checkTokenOwnershipBulk(
        address owner,
        IERC721 nftContract,
        uint256[] calldata tokenIds
    ) public view returns (bool) {
        for (uint256 i = 0; i < tokenIds.length; i++)
            try nftContract.ownerOf(tokenIds[i]) returns (address nftOwner) {
                if (owner != nftOwner) return false;
            } catch {
                return false;
            }
        return true;
    }

    function setOperators(
        address[] calldata operators,
        bool[] calldata isOperators
    ) external onlyOwner {
        require(
            operators.length == isOperators.length,
            "WAESUpgrade: the number of operators and the number of statuses must equal"
        );
        for (uint256 i = 0; i < operators.length; i++)
            _operators[operators[i]] = isOperators[i];
    }

    function updateConfigs(address waesAddress) external onlyOperators {
        WAES = IERC721(waesAddress);
    }

    function buyPickaxes(
        string calldata requestId,
        uint256 pickaxesPrice,
        uint256[] calldata tokenIds,
        uint256[] calldata extraData,
        bytes calldata signature
    ) external payable {
        require(
            !_requestIdUsed[requestId],
            "WAESUpgrade: the request ID has been used before"
        );

        // Verify signature
        bytes memory message = abi.encodePacked(
            msg.sender,
            requestId,
            pickaxesPrice
        );
        for (uint256 i = 0; i < tokenIds.length; i++)
            message = bytes.concat(message, abi.encodePacked(tokenIds[i]));
        for (uint256 i = 0; i < extraData.length; i++)
            message = bytes.concat(message, abi.encodePacked(extraData[i]));
        bytes32 messageHash = keccak256(message).toEthSignedMessageHash();
        require(
            _operators[messageHash.recover(signature)],
            "WAESUpgrade: the signature is invalid"
        );

        // Verify payment
        require(
            msg.value >= pickaxesPrice,
            "WAESUpgrade: the payment is insufficient"
        );
        if (msg.value > pickaxesPrice) {
            (bool success, ) = payable(msg.sender).call{
                value: msg.value - pickaxesPrice
            }("");
            require(
                success,
                "WAESUpgrade: the excess is failed to be returned"
            );
        }

        // Verify WAES ownership
        require(
            checkTokenOwnershipBulk(msg.sender, WAES, tokenIds),
            "WAESUpgrade: holders must own all these NFTs to upgrade"
        );

        _requestIdUsed[requestId] = true;

        emit PickaxesBought(requestId, pickaxesPrice, tokenIds, extraData);
    }

    function withdrawUpgradingFee(address recipient) external onlyOwner {
        (bool success, ) = payable(recipient).call{
            value: address(this).balance
        }("");
        require(
            success,
            "WAESUpgrade: the process of withdrawing airdrop fee is failed"
        );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"waesAddress","type":"address"}],"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":false,"internalType":"string","name":"requestId","type":"string"},{"indexed":false,"internalType":"uint256","name":"pickaxesPrice","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"extraData","type":"uint256[]"}],"name":"PickaxesBought","type":"event"},{"inputs":[],"name":"WAES","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"requestId","type":"string"},{"internalType":"uint256","name":"pickaxesPrice","type":"uint256"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"extraData","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"buyPickaxes","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"contract IERC721","name":"nftContract","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"checkTokenOwnershipBulk","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"operators","type":"address[]"},{"internalType":"bool[]","name":"isOperators","type":"bool[]"}],"name":"setOperators","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"waesAddress","type":"address"}],"name":"updateConfigs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"withdrawUpgradingFee","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x6080604052600436106100865760003560e01c806390770dfb1161005957806390770dfb1461011d578063ba788cb21461013d578063cd3859e114610150578063f2fde38b14610180578063f4305035146101a057600080fd5b80632b3caa3e1461008b5780633da400b9146100ad578063715018a6146100ea5780638da5cb5b146100ff575b600080fd5b34801561009757600080fd5b506100ab6100a6366004610de8565b6101c0565b005b3480156100b957600080fd5b506001546100cd906001600160a01b031681565b6040516001600160a01b0390911681526020015b60405180910390f35b3480156100f657600080fd5b506100ab61029a565b34801561010b57600080fd5b506000546001600160a01b03166100cd565b34801561012957600080fd5b506100ab610138366004610de8565b6102ae565b6100ab61014b366004610e93565b610343565b34801561015c57600080fd5b5061017061016b366004610f63565b61082b565b60405190151581526020016100e1565b34801561018c57600080fd5b506100ab61019b366004610de8565b610909565b3480156101ac57600080fd5b506100ab6101bb366004610fc8565b610982565b6101c8610ab0565b6000816001600160a01b03164760405160006040518083038185875af1925050503d8060008114610215576040519150601f19603f3d011682016040523d82523d6000602084013e61021a565b606091505b50509050806102965760405162461bcd60e51b815260206004820152603d60248201527f57414553557067726164653a207468652070726f63657373206f66207769746860448201527f64726177696e672061697264726f7020666565206973206661696c656400000060648201526084015b60405180910390fd5b5050565b6102a2610ab0565b6102ac6000610b0a565b565b3360009081526002602052604090205460ff166103215760405162461bcd60e51b815260206004820152602b60248201527f57414553557067726164653a207468652063616c6c6572206973206e6f74207460448201526a34329037b832b930ba37b960a91b606482015260840161028d565b600180546001600160a01b0319166001600160a01b0392909216919091179055565b60038989604051610355929190611028565b9081526040519081900360200190205460ff16156103ce5760405162461bcd60e51b815260206004820152603060248201527f57414553557067726164653a207468652072657175657374204944206861732060448201526f6265656e2075736564206265666f726560801b606482015260840161028d565b6000338a8a8a6040516020016103e79493929190611038565b604051602081830303815290604052905060005b86811015610471578188888381811061041657610416611065565b9050602002013560405160200161042f91815260200190565b60408051601f198184030181529082905261044d92916020016110ab565b60405160208183030381529060405291508080610469906110d6565b9150506103fb565b5060005b848110156104eb578186868381811061049057610490611065565b905060200201356040516020016104a991815260200190565b60408051601f19818403018152908290526104c792916020016110ab565b604051602081830303815290604052915080806104e3906110d6565b915050610475565b508051602080830191909120604080517f19457468657265756d205369676e6564204d6573736167653a0a33320000000081850152603c8082019390935281518082039093018352605c01905280519101206002600061058386868080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152508793925050610b5a9050565b6001600160a01b0316815260208101919091526040016000205460ff166105fa5760405162461bcd60e51b815260206004820152602560248201527f57414553557067726164653a20746865207369676e617475726520697320696e6044820152641d985b1a5960da1b606482015260840161028d565b8834101561065b5760405162461bcd60e51b815260206004820152602860248201527f57414553557067726164653a20746865207061796d656e7420697320696e737560448201526719999a58da595b9d60c21b606482015260840161028d565b8834111561071d576000336106708b346110ef565b604051600081818185875af1925050503d80600081146106ac576040519150601f19603f3d011682016040523d82523d6000602084013e6106b1565b606091505b505090508061071b5760405162461bcd60e51b815260206004820152603060248201527f57414553557067726164653a2074686520657863657373206973206661696c6560448201526f19081d1bc81899481c995d1d5c9b995960821b606482015260840161028d565b505b6001546107369033906001600160a01b03168a8a61082b565b6107a85760405162461bcd60e51b815260206004820152603760248201527f57414553557067726164653a20686f6c64657273206d757374206f776e20616c60448201527f6c207468657365204e46547320746f2075706772616465000000000000000000606482015260840161028d565b600160038c8c6040516107bc929190611028565b908152604051908190036020018120805492151560ff19909316929092179091557f7bcdd96187cdc337978446981f89249beac2d0b6b1d081f1baf40c152589c34290610816908d908d908d908d908d908d908d90611134565b60405180910390a15050505050505050505050565b6000805b828110156108fb57846001600160a01b0316636352211e85858481811061085857610858611065565b905060200201356040518263ffffffff1660e01b815260040161087d91815260200190565b602060405180830381865afa9250505080156108b6575060408051601f3d908101601f191682019092526108b39181019061119c565b60015b6108c4576000915050610901565b806001600160a01b0316876001600160a01b0316146108e857600092505050610901565b50806108f3816110d6565b91505061082f565b50600190505b949350505050565b610911610ab0565b6001600160a01b0381166109765760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161028d565b61097f81610b0a565b50565b61098a610ab0565b828114610a125760405162461bcd60e51b815260206004820152604a60248201527f57414553557067726164653a20746865206e756d626572206f66206f7065726160448201527f746f727320616e6420746865206e756d626572206f66207374617475736573206064820152691b5d5cdd08195c5d585b60b21b608482015260a40161028d565b60005b83811015610aa957828282818110610a2f57610a2f611065565b9050602002016020810190610a4491906111b9565b60026000878785818110610a5a57610a5a611065565b9050602002016020810190610a6f9190610de8565b6001600160a01b031681526020810191909152604001600020805460ff191691151591909117905580610aa1816110d6565b915050610a15565b5050505050565b6000546001600160a01b031633146102ac5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161028d565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6000806000610b698585610b80565b91509150610b7681610bc5565b5090505b92915050565b6000808251604103610bb65760208301516040840151606085015160001a610baa87828585610d0f565b94509450505050610bbe565b506000905060025b9250929050565b6000816004811115610bd957610bd96111db565b03610be15750565b6001816004811115610bf557610bf56111db565b03610c425760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e61747572650000000000000000604482015260640161028d565b6002816004811115610c5657610c566111db565b03610ca35760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e67746800604482015260640161028d565b6003816004811115610cb757610cb76111db565b0361097f5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b606482015260840161028d565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115610d465750600090506003610dca565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015610d9a573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116610dc357600060019250925050610dca565b9150600090505b94509492505050565b6001600160a01b038116811461097f57600080fd5b600060208284031215610dfa57600080fd5b8135610e0581610dd3565b9392505050565b60008083601f840112610e1e57600080fd5b50813567ffffffffffffffff811115610e3657600080fd5b602083019150836020828501011115610bbe57600080fd5b60008083601f840112610e6057600080fd5b50813567ffffffffffffffff811115610e7857600080fd5b6020830191508360208260051b8501011115610bbe57600080fd5b600080600080600080600080600060a08a8c031215610eb157600080fd5b893567ffffffffffffffff80821115610ec957600080fd5b610ed58d838e01610e0c565b909b50995060208c0135985060408c0135915080821115610ef557600080fd5b610f018d838e01610e4e565b909850965060608c0135915080821115610f1a57600080fd5b610f268d838e01610e4e565b909650945060808c0135915080821115610f3f57600080fd5b50610f4c8c828d01610e0c565b915080935050809150509295985092959850929598565b60008060008060608587031215610f7957600080fd5b8435610f8481610dd3565b93506020850135610f9481610dd3565b9250604085013567ffffffffffffffff811115610fb057600080fd5b610fbc87828801610e4e565b95989497509550505050565b60008060008060408587031215610fde57600080fd5b843567ffffffffffffffff80821115610ff657600080fd5b61100288838901610e4e565b9096509450602087013591508082111561101b57600080fd5b50610fbc87828801610e4e565b8183823760009101908152919050565b6bffffffffffffffffffffffff198560601b16815282846014830137601492019182015260340192915050565b634e487b7160e01b600052603260045260246000fd5b6000815160005b8181101561109c5760208185018101518683015201611082565b50600093019283525090919050565b60006109016110ba838661107b565b8461107b565b634e487b7160e01b600052601160045260246000fd5b6000600182016110e8576110e86110c0565b5060010190565b81810381811115610b7a57610b7a6110c0565b81835260006001600160fb1b0383111561111b57600080fd5b8260051b80836020870137939093016020019392505050565b60808152866080820152868860a0830137600060a088830101526000601f19601f890116820187602084015260a083820301604084015261117960a082018789611102565b9050828103606084015261118e818587611102565b9a9950505050505050505050565b6000602082840312156111ae57600080fd5b8151610e0581610dd3565b6000602082840312156111cb57600080fd5b81358015158114610e0557600080fd5b634e487b7160e01b600052602160045260246000fdfea264697066735822122067a414db46e82ac80b41f2f7e0e462d6851df82a90cd6bd5f4b2cd2a8743de6264736f6c63430008120033

0000000000000000000000001c3de91f00c68c1965c9dfbf00cd3cc54cb9a388

-----Decoded View---------------
Arg [0] : waesAddress (address): 0x1C3de91f00c68c1965c9Dfbf00cD3cc54Cb9a388

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000001c3de91f00c68c1965c9dfbf00cd3cc54cb9a388

33779:3815:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37275:316;;;;;;;;;;-1:-1:-1;37275:316:0;;;;;:::i;:::-;;:::i;:::-;;33850:19;;;;;;;;;;-1:-1:-1;33850:19:0;;;;-1:-1:-1;;;;;33850:19:0;;;;;;-1:-1:-1;;;;;581:32:1;;;563:51;;551:2;536:18;33850:19:0;;;;;;;;2887:103;;;;;;;;;;;;;:::i;2239:87::-;;;;;;;;;;-1:-1:-1;2285:7:0;2312:6;-1:-1:-1;;;;;2312:6:0;2239:87;;35331:113;;;;;;;;;;-1:-1:-1;35331:113:0;;;;;:::i;:::-;;:::i;35452:1815::-;;;;;;:::i;:::-;;:::i;34451:446::-;;;;;;;;;;-1:-1:-1;34451:446:0;;;;;:::i;:::-;;:::i;:::-;;;3881:14:1;;3874:22;3856:41;;3844:2;3829:18;34451:446:0;3716:187:1;3145:201:0;;;;;;;;;;-1:-1:-1;3145:201:0;;;;;:::i;:::-;;:::i;34905:418::-;;;;;;;;;;-1:-1:-1;34905:418:0;;;;;:::i;:::-;;:::i;37275:316::-;2125:13;:11;:13::i;:::-;37355:12:::1;37381:9;-1:-1:-1::0;;;;;37373:23:0::1;37418:21;37373:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37354:100;;;37487:7;37465:118;;;::::0;-1:-1:-1;;;37465:118:0;;5095:2:1;37465:118:0::1;::::0;::::1;5077:21:1::0;5134:2;5114:18;;;5107:30;5173:34;5153:18;;;5146:62;5244:31;5224:18;;;5217:59;5293:19;;37465:118:0::1;;;;;;;;;37343:248;37275:316:::0;:::o;2887:103::-;2125:13;:11;:13::i;:::-;2952:30:::1;2979:1;2952:18;:30::i;:::-;2887:103::o:0;35331:113::-;34341:10;34330:22;;;;:10;:22;;;;;;;;34308:115;;;;-1:-1:-1;;;34308:115:0;;5525:2:1;34308:115:0;;;5507:21:1;5564:2;5544:18;;;5537:30;5603:34;5583:18;;;5576:62;-1:-1:-1;;;5654:18:1;;;5647:41;5705:19;;34308:115:0;5323:407:1;34308:115:0;35409:4:::1;:27:::0;;-1:-1:-1;;;;;;35409:27:0::1;-1:-1:-1::0;;;;;35409:27:0;;;::::1;::::0;;;::::1;::::0;;35331:113::o;35452:1815::-;35711:14;35726:9;;35711:25;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;35710:26;35688:124;;;;-1:-1:-1;;;35688:124:0;;6215:2:1;35688:124:0;;;6197:21:1;6254:2;6234:18;;;6227:30;6293:34;6273:18;;;6266:62;-1:-1:-1;;;6344:18:1;;;6337:46;6400:19;;35688:124:0;6013:412:1;35688:124:0;35854:20;35908:10;35933:9;;35957:13;35877:104;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;35854:127;;35997:9;35992:121;36012:19;;;35992:121;;;36074:7;36100:8;;36109:1;36100:11;;;;;;;:::i;:::-;;;;;;;36083:29;;;;;;7132:19:1;;7176:2;7167:12;;7003:182;36083:29:0;;;;-1:-1:-1;;36083:29:0;;;;;;;;;;36061:52;;;36083:29;36061:52;;:::i;:::-;;;;;;;;;;;;;36051:62;;36033:3;;;;;:::i;:::-;;;;35992:121;;;;36129:9;36124:123;36144:20;;;36124:123;;;36207:7;36233:9;;36243:1;36233:12;;;;;;;:::i;:::-;;;;;;;36216:30;;;;;;7132:19:1;;7176:2;7167:12;;7003:182;36216:30:0;;;;-1:-1:-1;;36216:30:0;;;;;;;;;;36194:53;;;36216:30;36194:53;;:::i;:::-;;;;;;;;;;;;;36184:63;;36166:3;;;;;:::i;:::-;;;;36124:123;;;-1:-1:-1;36280:18:0;;;;;;;;;;32596:58;;;13302:66:1;32596:58:0;;;13290:79:1;13385:12;;;;13378:28;;;;32596:58:0;;;;;;;;;;13422:12:1;;32596:58:0;;32586:69;;;;;36356:10;:42;36367:30;36387:9;;36367:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36367:11:0;;:30;-1:-1:-1;;36367:19:0;:30;-1:-1:-1;36367:30:0:i;:::-;-1:-1:-1;;;;;36356:42:0;;;;;;;;;;;;-1:-1:-1;36356:42:0;;;;36334:129;;;;-1:-1:-1;;;36334:129:0;;8257:2:1;36334:129:0;;;8239:21:1;8296:2;8276:18;;;8269:30;8335:34;8315:18;;;8308:62;-1:-1:-1;;;8386:18:1;;;8379:35;8431:19;;36334:129:0;8055:401:1;36334:129:0;36538:13;36525:9;:26;;36503:116;;;;-1:-1:-1;;;36503:116:0;;8663:2:1;36503:116:0;;;8645:21:1;8702:2;8682:18;;;8675:30;8741:34;8721:18;;;8714:62;-1:-1:-1;;;8792:18:1;;;8785:38;8840:19;;36503:116:0;8461:404:1;36503:116:0;36646:13;36634:9;:25;36630:303;;;36677:12;36703:10;36745:25;36757:13;36745:9;:25;:::i;:::-;36695:94;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36676:113;;;36830:7;36804:117;;;;-1:-1:-1;;;36804:117:0;;9205:2:1;36804:117:0;;;9187:21:1;9244:2;9224:18;;;9217:30;9283:34;9263:18;;;9256:62;-1:-1:-1;;;9334:18:1;;;9327:46;9390:19;;36804:117:0;9003:412:1;36804:117:0;36661:272;36630:303;37037:4;;37001:51;;37025:10;;-1:-1:-1;;;;;37037:4:0;37043:8;;37001:23;:51::i;:::-;36979:156;;;;-1:-1:-1;;;36979:156:0;;9622:2:1;36979:156:0;;;9604:21:1;9661:2;9641:18;;;9634:30;9700:34;9680:18;;;9673:62;9771:25;9751:18;;;9744:53;9814:19;;36979:156:0;9420:419:1;36979:156:0;37176:4;37148:14;37163:9;;37148:25;;;;;;;:::i;:::-;;;;;;;;;;;;;;:32;;;;;-1:-1:-1;;37148:32:0;;;;;;;;;;37198:61;;;;37213:9;;;;37224:13;;37239:8;;;;37249:9;;;;37198:61;:::i;:::-;;;;;;;;35677:1590;;35452:1815;;;;;;;;;:::o;34451:446::-;34604:4;;34621:247;34641:19;;;34621:247;;;34684:11;-1:-1:-1;;;;;34684:19:0;;34704:8;;34713:1;34704:11;;;;;;;:::i;:::-;;;;;;;34684:32;;;;;;;;;;;;;11239:25:1;;11227:2;11212:18;;11093:177;34684:32:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;34684:32:0;;;;;;;;-1:-1:-1;;34684:32:0;;;;;;;;;;;;:::i;:::-;;;34680:188;;34847:5;34840:12;;;;;34680:188;34776:8;-1:-1:-1;;;;;34767:17:0;:5;-1:-1:-1;;;;;34767:17:0;;34763:35;;34793:5;34786:12;;;;;;34763:35;34717:97;34662:3;;;;:::i;:::-;;;;34621:247;;;;34885:4;34878:11;;34451:446;;;;;;;:::o;3145:201::-;2125:13;:11;:13::i;:::-;-1:-1:-1;;;;;3234:22:0;::::1;3226:73;;;::::0;-1:-1:-1;;;3226:73:0;;11733:2:1;3226:73:0::1;::::0;::::1;11715:21:1::0;11772:2;11752:18;;;11745:30;11811:34;11791:18;;;11784:62;-1:-1:-1;;;11862:18:1;;;11855:36;11908:19;;3226:73:0::1;11531:402:1::0;3226:73:0::1;3310:28;3329:8;3310:18;:28::i;:::-;3145:201:::0;:::o;34905:418::-;2125:13;:11;:13::i;:::-;35063:38;;::::1;35041:162;;;::::0;-1:-1:-1;;;35041:162:0;;12140:2:1;35041:162:0::1;::::0;::::1;12122:21:1::0;12179:2;12159:18;;;12152:30;12218:34;12198:18;;;12191:62;12289:34;12269:18;;;12262:62;-1:-1:-1;;;12340:19:1;;;12333:41;12391:19;;35041:162:0::1;11938:478:1::0;35041:162:0::1;35219:9;35214:101;35234:20:::0;;::::1;35214:101;;;35301:11;;35313:1;35301:14;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;35274:10;:24;35285:9;;35295:1;35285:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;35274:24:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;35274:24:0;:41;;-1:-1:-1;;35274:41:0::1;::::0;::::1;;::::0;;;::::1;::::0;;35256:3;::::1;::::0;::::1;:::i;:::-;;;;35214:101;;;;34905:418:::0;;;;:::o;2404:132::-;2285:7;2312:6;-1:-1:-1;;;;;2312:6:0;866:10;2468:23;2460:68;;;;-1:-1:-1;;;2460:68:0;;12901:2:1;2460:68:0;;;12883:21:1;;;12920:18;;;12913:30;12979:34;12959:18;;;12952:62;13031:18;;2460:68:0;12699:356:1;3506:191:0;3580:16;3599:6;;-1:-1:-1;;;;;3616:17:0;;;-1:-1:-1;;;;;;3616:17:0;;;;;;3649:40;;3599:6;;;;;;;3649:40;;3580:16;3649:40;3569:128;3506:191;:::o;28704:231::-;28782:7;28803:17;28822:18;28844:27;28855:4;28861:9;28844:10;:27::i;:::-;28802:69;;;;28882:18;28894:5;28882:11;:18::i;:::-;-1:-1:-1;28918:9:0;-1:-1:-1;28704:231:0;;;;;:::o;27155:747::-;27236:7;27245:12;27274:9;:16;27294:2;27274:22;27270:625;;27618:4;27603:20;;27597:27;27668:4;27653:20;;27647:27;27726:4;27711:20;;27705:27;27313:9;27697:36;27769:25;27780:4;27697:36;27597:27;27647;27769:10;:25::i;:::-;27762:32;;;;;;;;;27270:625;-1:-1:-1;27843:1:0;;-1:-1:-1;27847:35:0;27270:625;27155:747;;;;;:::o;25548:521::-;25626:20;25617:5;:29;;;;;;;;:::i;:::-;;25613:449;;25548:521;:::o;25613:449::-;25724:29;25715:5;:38;;;;;;;;:::i;:::-;;25711:351;;25770:34;;-1:-1:-1;;;25770:34:0;;13779:2:1;25770:34:0;;;13761:21:1;13818:2;13798:18;;;13791:30;13857:26;13837:18;;;13830:54;13901:18;;25770:34:0;13577:348:1;25711:351:0;25835:35;25826:5;:44;;;;;;;;:::i;:::-;;25822:240;;25887:41;;-1:-1:-1;;;25887:41:0;;14132:2:1;25887:41:0;;;14114:21:1;14171:2;14151:18;;;14144:30;14210:33;14190:18;;;14183:61;14261:18;;25887:41:0;13930:355:1;25822:240:0;25959:30;25950:5;:39;;;;;;;;:::i;:::-;;25946:116;;26006:44;;-1:-1:-1;;;26006:44:0;;14492:2:1;26006:44:0;;;14474:21:1;14531:2;14511:18;;;14504:30;14570:34;14550:18;;;14543:62;-1:-1:-1;;;14621:18:1;;;14614:32;14663:19;;26006:44:0;14290:398:1;30156:1520:0;30287:7;;31221:66;31208:79;;31204:163;;;-1:-1:-1;31320:1:0;;-1:-1:-1;31324:30:0;31304:51;;31204:163;31481:24;;;31464:14;31481:24;;;;;;;;;14920:25:1;;;14993:4;14981:17;;14961:18;;;14954:45;;;;15015:18;;;15008:34;;;15058:18;;;15051:34;;;31481:24:0;;14892:19:1;;31481:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31481:24:0;;-1:-1:-1;;31481:24:0;;;-1:-1:-1;;;;;;;31520:20:0;;31516:103;;31573:1;31577:29;31557:50;;;;;;;31516:103;31639:6;-1:-1:-1;31647:20:0;;-1:-1:-1;30156:1520:0;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:247;209:6;262:2;250:9;241:7;237:23;233:32;230:52;;;278:1;275;268:12;230:52;317:9;304:23;336:31;361:5;336:31;:::i;:::-;386:5;150:247;-1:-1:-1;;;150:247:1:o;833:348::-;885:8;895:6;949:3;942:4;934:6;930:17;926:27;916:55;;967:1;964;957:12;916:55;-1:-1:-1;990:20:1;;1033:18;1022:30;;1019:50;;;1065:1;1062;1055:12;1019:50;1102:4;1094:6;1090:17;1078:29;;1154:3;1147:4;1138:6;1130;1126:19;1122:30;1119:39;1116:59;;;1171:1;1168;1161:12;1186:367;1249:8;1259:6;1313:3;1306:4;1298:6;1294:17;1290:27;1280:55;;1331:1;1328;1321:12;1280:55;-1:-1:-1;1354:20:1;;1397:18;1386:30;;1383:50;;;1429:1;1426;1419:12;1383:50;1466:4;1458:6;1454:17;1442:29;;1526:3;1519:4;1509:6;1506:1;1502:14;1494:6;1490:27;1486:38;1483:47;1480:67;;;1543:1;1540;1533:12;1558:1420;1730:6;1738;1746;1754;1762;1770;1778;1786;1794;1847:3;1835:9;1826:7;1822:23;1818:33;1815:53;;;1864:1;1861;1854:12;1815:53;1904:9;1891:23;1933:18;1974:2;1966:6;1963:14;1960:34;;;1990:1;1987;1980:12;1960:34;2029:59;2080:7;2071:6;2060:9;2056:22;2029:59;:::i;:::-;2107:8;;-1:-1:-1;2003:85:1;-1:-1:-1;2189:2:1;2174:18;;2161:32;;-1:-1:-1;2246:2:1;2231:18;;2218:32;;-1:-1:-1;2262:16:1;;;2259:36;;;2291:1;2288;2281:12;2259:36;2330:72;2394:7;2383:8;2372:9;2368:24;2330:72;:::i;:::-;2421:8;;-1:-1:-1;2304:98:1;-1:-1:-1;2509:2:1;2494:18;;2481:32;;-1:-1:-1;2525:16:1;;;2522:36;;;2554:1;2551;2544:12;2522:36;2593:72;2657:7;2646:8;2635:9;2631:24;2593:72;:::i;:::-;2684:8;;-1:-1:-1;2567:98:1;-1:-1:-1;2772:3:1;2757:19;;2744:33;;-1:-1:-1;2789:16:1;;;2786:36;;;2818:1;2815;2808:12;2786:36;;2857:61;2910:7;2899:8;2888:9;2884:24;2857:61;:::i;:::-;2831:87;;2937:8;2927:18;;;2964:8;2954:18;;;1558:1420;;;;;;;;;;;:::o;2983:728::-;3102:6;3110;3118;3126;3179:2;3167:9;3158:7;3154:23;3150:32;3147:52;;;3195:1;3192;3185:12;3147:52;3234:9;3221:23;3253:31;3278:5;3253:31;:::i;:::-;3303:5;-1:-1:-1;3360:2:1;3345:18;;3332:32;3373:33;3332:32;3373:33;:::i;:::-;3425:7;-1:-1:-1;3483:2:1;3468:18;;3455:32;3510:18;3499:30;;3496:50;;;3542:1;3539;3532:12;3496:50;3581:70;3643:7;3634:6;3623:9;3619:22;3581:70;:::i;:::-;2983:728;;;;-1:-1:-1;3670:8:1;-1:-1:-1;;;;2983:728:1:o;3908:770::-;4027:6;4035;4043;4051;4104:2;4092:9;4083:7;4079:23;4075:32;4072:52;;;4120:1;4117;4110:12;4072:52;4160:9;4147:23;4189:18;4230:2;4222:6;4219:14;4216:34;;;4246:1;4243;4236:12;4216:34;4285:70;4347:7;4338:6;4327:9;4323:22;4285:70;:::i;:::-;4374:8;;-1:-1:-1;4259:96:1;-1:-1:-1;4462:2:1;4447:18;;4434:32;;-1:-1:-1;4478:16:1;;;4475:36;;;4507:1;4504;4497:12;4475:36;;4546:72;4610:7;4599:8;4588:9;4584:24;4546:72;:::i;5735:273::-;5920:6;5912;5907:3;5894:33;5876:3;5946:16;;5971:13;;;5946:16;5735:273;-1:-1:-1;5735:273:1:o;6430:436::-;6682:26;6678:31;6669:6;6665:2;6661:15;6657:53;6652:3;6645:66;6755:6;6747;6742:2;6737:3;6733:12;6720:42;6821:2;6781:16;;6813:11;;;6806:27;6857:2;6849:11;;6430:436;-1:-1:-1;;6430:436:1:o;6871:127::-;6932:10;6927:3;6923:20;6920:1;6913:31;6963:4;6960:1;6953:15;6987:4;6984:1;6977:15;7190:322;7231:3;7269:5;7263:12;7293:1;7303:128;7317:6;7314:1;7311:13;7303:128;;;7414:4;7399:13;;;7395:24;;7389:31;7376:11;;;7369:52;7332:12;7303:128;;;-1:-1:-1;7486:1:1;7450:16;;7475:13;;;-1:-1:-1;7450:16:1;;7190:322;-1:-1:-1;7190:322:1:o;7517:261::-;7692:3;7717:55;7742:29;7767:3;7759:6;7742:29;:::i;:::-;7734:6;7717:55;:::i;7783:127::-;7844:10;7839:3;7835:20;7832:1;7825:31;7875:4;7872:1;7865:15;7899:4;7896:1;7889:15;7915:135;7954:3;7975:17;;;7972:43;;7995:18;;:::i;:::-;-1:-1:-1;8042:1:1;8031:13;;7915:135::o;8870:128::-;8937:9;;;8958:11;;;8955:37;;;8972:18;;:::i;9844:311::-;9932:19;;;9914:3;-1:-1:-1;;;;;9963:31:1;;9960:51;;;10007:1;10004;9997:12;9960:51;10043:6;10040:1;10036:14;10095:8;10088:5;10081:4;10076:3;10072:14;10059:45;10124:18;;;;10144:4;10120:29;;9844:311;-1:-1:-1;;;9844:311:1:o;10160:928::-;10523:3;10512:9;10505:22;10564:6;10558:3;10547:9;10543:19;10536:35;10622:6;10614;10608:3;10597:9;10593:19;10580:49;10679:1;10673:3;10664:6;10653:9;10649:22;10645:32;10638:43;10486:4;10740:2;10736:7;10731:2;10723:6;10719:15;10715:29;10704:9;10700:45;10783:6;10776:4;10765:9;10761:20;10754:36;10850:3;10838:9;10834:2;10830:18;10826:28;10821:2;10810:9;10806:18;10799:56;10878:67;10940:3;10936:2;10932:12;10924:6;10916;10878:67;:::i;:::-;10864:81;;10993:9;10985:6;10981:22;10976:2;10965:9;10961:18;10954:50;11021:61;11075:6;11067;11059;11021:61;:::i;:::-;11013:69;10160:928;-1:-1:-1;;;;;;;;;;10160:928:1:o;11275:251::-;11345:6;11398:2;11386:9;11377:7;11373:23;11369:32;11366:52;;;11414:1;11411;11404:12;11366:52;11446:9;11440:16;11465:31;11490:5;11465:31;:::i;12421:273::-;12477:6;12530:2;12518:9;12509:7;12505:23;12501:32;12498:52;;;12546:1;12543;12536:12;12498:52;12585:9;12572:23;12638:5;12631:13;12624:21;12617:5;12614:32;12604:60;;12660:1;12657;12650:12;13445:127;13506:10;13501:3;13497:20;13494:1;13487:31;13537:4;13534:1;13527:15;13561:4;13558:1;13551:15

ipfs://67a414db46e82ac80b41f2f7e0e462d6851df82a90cd6bd5f4b2cd2a8743de62