Token

Pocket Wallet (ORIGIN)

ERC-721

Overview

Max Total Supply

21 ORIGIN

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xd8c8af693e762a839e5da23ae137ae51672206a3

Filtered by Token Holder

0x8C1d01ACE77C85BfBa08ea3d1a05fb8006b3d8E6

bandemic.eth

Balance

1 ORIGIN

0x8c1d01ace77c85bfba08ea3d1a05fb8006b3d8e6

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ORIGIN

Compiler Version

v0.8.9+commit.e5eed63a

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-09-14
*/

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/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/token/ERC721/IERC721.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// 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/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @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.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _ownerOf(tokenId) != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId, 1);

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

// 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: contracts/OriginNFT.sol



pragma solidity ^0.8.9;



contract ORIGIN is ERC721, Ownable {
    using Strings for uint256;

    uint public constant MAX_TOKENS = 50;
    uint private constant TOKENS_RESERVED = 5;
    uint public price = 1000000000000000;
    uint256 public constant MAX_MINT_PER_TX = 1;

    bool public isSaleActive;
    uint256 public totalSupply;
    mapping(address => uint256) private mintedPerWallet;

    string public baseUri;
    string public baseExtension = ".json";

    constructor() ERC721("Pocket Wallet", "ORIGIN") {
        baseUri = "ipfs://bafkreidmaitq7kdxk5w2frs4jaje5mid7knq3o7w7bh5kiumcnx6qfpg5i";
        for(uint256 i = 1; i <= TOKENS_RESERVED; ++i) {
            _safeMint(msg.sender, i);
        }
        totalSupply = TOKENS_RESERVED;
    }

    // Public Functions
    function mint(uint256 _numTokens) external payable {
        require(isSaleActive, "The sale is paused.");
        require(_numTokens <= MAX_MINT_PER_TX, "You cannot mint that many in one transaction.");
        require(mintedPerWallet[msg.sender] + _numTokens <= 1, "You can only mint 1 per wallet.");
        uint256 curTotalSupply = totalSupply;
        require(curTotalSupply + _numTokens <= MAX_TOKENS, "Exceeds total supply.");
        require(_numTokens * price <= msg.value, "Insufficient funds.");

        for(uint256 i = 1; i <= _numTokens; ++i) {
            _safeMint(msg.sender, curTotalSupply + i);
        }
        mintedPerWallet[msg.sender] += _numTokens;
        totalSupply += _numTokens;
    }

    // Owner-only functions
    function flipSaleState() external onlyOwner {
        isSaleActive = !isSaleActive;
    }

    function setBaseUri(string memory _baseUri) external onlyOwner {
        baseUri = _baseUri;
    }

    function setPrice(uint256 _price) external onlyOwner {
        price = _price;
    }

    function withdrawAll() external payable onlyOwner {
        uint256 balance = address(this).balance;
        uint256 balanceOne = balance * 50 / 100;
        uint256 balanceTwo = balance * 50 / 100;
        ( bool transferOne, ) = payable(0xf39380064D86095eda643Db1100012972Cf91ef0).call{value: balanceOne}("");
        ( bool transferTwo, ) = payable(0xf39380064D86095eda643Db1100012972Cf91ef0).call{value: balanceTwo}("");
        require(transferOne && transferTwo, "Transfer failed.");
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
 
        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0
            ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
            : "";
    }
 
    function _baseURI() internal view virtual override returns (string memory) {
        return baseUri;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"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":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_MINT_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseUri","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

66038d7ea4c6800060075560c06040526005608081905264173539b7b760d91b60a09081526200003391600c919062000531565b503480156200004157600080fd5b50604080518082018252600d81526c141bd8dad95d0815d85b1b195d609a1b60208083019182528351808501909452600684526527a924a3a4a760d11b908401528151919291620000959160009162000531565b508051620000ab90600190602084019062000531565b505050620000c8620000c26200013060201b60201c565b62000134565b6040518060800160405280604281526020016200252b604291398051620000f891600b9160209091019062000531565b5060015b60058111620001245762000111338262000186565b6200011c81620005d7565b9050620000fc565b506005600955620006ec565b3390565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b620001a8828260405180602001604052806000815250620001ac60201b60201c565b5050565b620001b8838362000228565b620001c76000848484620003b9565b620002235760405162461bcd60e51b815260206004820152603260248201526000805160206200250b83398151915260448201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b60648201526084015b60405180910390fd5b505050565b6001600160a01b038216620002805760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f206164647265737360448201526064016200021a565b6000818152600260205260409020546001600160a01b031615620002e75760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e7465640000000060448201526064016200021a565b6000818152600260205260409020546001600160a01b0316156200034e5760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e7465640000000060448201526064016200021a565b6001600160a01b038216600081815260036020908152604080832080546001019055848352600290915280822080546001600160a01b0319168417905551839291907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b6000620003da846001600160a01b03166200052260201b62000e8f1760201c565b156200051657604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906200041490339089908890889060040162000601565b602060405180830381600087803b1580156200042f57600080fd5b505af192505050801562000462575060408051601f3d908101601f191682019092526200045f918101906200067c565b60015b620004fb573d80801562000493576040519150601f19603f3d011682016040523d82523d6000602084013e62000498565b606091505b508051620004f35760405162461bcd60e51b815260206004820152603260248201526000805160206200250b83398151915260448201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b60648201526084016200021a565b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490506200051a565b5060015b949350505050565b6001600160a01b03163b151590565b8280546200053f90620006af565b90600052602060002090601f016020900481019282620005635760008555620005ae565b82601f106200057e57805160ff1916838001178555620005ae565b82800160010185558215620005ae579182015b82811115620005ae57825182559160200191906001019062000591565b50620005bc929150620005c0565b5090565b5b80821115620005bc5760008155600101620005c1565b6000600019821415620005fa57634e487b7160e01b600052601160045260246000fd5b5060010190565b600060018060a01b038087168352602081871681850152856040850152608060608501528451915081608085015260005b82811015620006505785810182015185820160a00152810162000632565b828111156200066357600060a084870101525b5050601f01601f19169190910160a00195945050505050565b6000602082840312156200068f57600080fd5b81516001600160e01b031981168114620006a857600080fd5b9392505050565b600181811c90821680620006c457607f821691505b60208210811415620006e657634e487b7160e01b600052602260045260246000fd5b50919050565b611e0f80620006fc6000396000f3fe6080604052600436106101b75760003560e01c80638ecad721116100ec578063a22cb4651161008a578063c87b56dd11610064578063c87b56dd14610478578063e985e9c514610498578063f2fde38b146104e1578063f47c84c51461050157600080fd5b8063a22cb46514610423578063b88d4fde14610443578063c66828621461046357600080fd5b80639abc8320116100c65780639abc8320146103c5578063a035b1fe146103da578063a0712d68146103f0578063a0bcfc7f1461040357600080fd5b80638ecad7211461037b57806391b7f5ed1461039057806395d89b41146103b057600080fd5b806342842e0e1161015957806370a082311161013357806370a0823114610320578063715018a614610340578063853828b6146103555780638da5cb5b1461035d57600080fd5b806342842e0e146102c6578063564566a8146102e65780636352211e1461030057600080fd5b8063095ea7b311610195578063095ea7b31461024b57806318160ddd1461026d57806323b872dd1461029157806334918dfd146102b157600080fd5b806301ffc9a7146101bc57806306fdde03146101f1578063081812fc14610213575b600080fd5b3480156101c857600080fd5b506101dc6101d7366004611814565b610516565b60405190151581526020015b60405180910390f35b3480156101fd57600080fd5b50610206610568565b6040516101e89190611889565b34801561021f57600080fd5b5061023361022e36600461189c565b6105fa565b6040516001600160a01b0390911681526020016101e8565b34801561025757600080fd5b5061026b6102663660046118d1565b610621565b005b34801561027957600080fd5b5061028360095481565b6040519081526020016101e8565b34801561029d57600080fd5b5061026b6102ac3660046118fb565b61073c565b3480156102bd57600080fd5b5061026b61076d565b3480156102d257600080fd5b5061026b6102e13660046118fb565b610789565b3480156102f257600080fd5b506008546101dc9060ff1681565b34801561030c57600080fd5b5061023361031b36600461189c565b6107a4565b34801561032c57600080fd5b5061028361033b366004611937565b610804565b34801561034c57600080fd5b5061026b61088a565b61026b61089e565b34801561036957600080fd5b506006546001600160a01b0316610233565b34801561038757600080fd5b50610283600181565b34801561039c57600080fd5b5061026b6103ab36600461189c565b6109ed565b3480156103bc57600080fd5b506102066109fa565b3480156103d157600080fd5b50610206610a09565b3480156103e657600080fd5b5061028360075481565b61026b6103fe36600461189c565b610a97565b34801561040f57600080fd5b5061026b61041e3660046119de565b610cc9565b34801561042f57600080fd5b5061026b61043e366004611a27565b610ce8565b34801561044f57600080fd5b5061026b61045e366004611a63565b610cf3565b34801561046f57600080fd5b50610206610d2b565b34801561048457600080fd5b5061020661049336600461189c565b610d38565b3480156104a457600080fd5b506101dc6104b3366004611adf565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b3480156104ed57600080fd5b5061026b6104fc366004611937565b610e16565b34801561050d57600080fd5b50610283603281565b60006001600160e01b031982166380ac58cd60e01b148061054757506001600160e01b03198216635b5e139f60e01b145b8061056257506301ffc9a760e01b6001600160e01b03198316145b92915050565b60606000805461057790611b12565b80601f01602080910402602001604051908101604052809291908181526020018280546105a390611b12565b80156105f05780601f106105c5576101008083540402835291602001916105f0565b820191906000526020600020905b8154815290600101906020018083116105d357829003601f168201915b5050505050905090565b600061060582610e9e565b506000908152600460205260409020546001600160a01b031690565b600061062c826107a4565b9050806001600160a01b0316836001600160a01b0316141561069f5760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b60648201526084015b60405180910390fd5b336001600160a01b03821614806106bb57506106bb81336104b3565b61072d5760405162461bcd60e51b815260206004820152603d60248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f60448201527f6b656e206f776e6572206f7220617070726f76656420666f7220616c6c0000006064820152608401610696565b6107378383610efd565b505050565b6107463382610f6b565b6107625760405162461bcd60e51b815260040161069690611b4d565b610737838383610fea565b61077561114e565b6008805460ff19811660ff90911615179055565b61073783838360405180602001604052806000815250610cf3565b6000818152600260205260408120546001600160a01b0316806105625760405162461bcd60e51b8152602060048201526018602482015277115490cdcc8c4e881a5b9d985b1a59081d1bdad95b88125160421b6044820152606401610696565b60006001600160a01b03821661086e5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a2061646472657373207a65726f206973206e6f7420612076616044820152683634b21037bbb732b960b91b6064820152608401610696565b506001600160a01b031660009081526003602052604090205490565b61089261114e565b61089c60006111a8565b565b6108a661114e565b47600060646108b6836032611bb0565b6108c09190611bcf565b9050600060646108d1846032611bb0565b6108db9190611bcf565b60405190915060009073f39380064d86095eda643db1100012972cf91ef09084908381818185875af1925050503d8060008114610934576040519150601f19603f3d011682016040523d82523d6000602084013e610939565b606091505b505060405190915060009073f39380064d86095eda643db1100012972cf91ef09084908381818185875af1925050503d8060008114610994576040519150601f19603f3d011682016040523d82523d6000602084013e610999565b606091505b505090508180156109a75750805b6109e65760405162461bcd60e51b815260206004820152601060248201526f2a3930b739b332b9103330b4b632b21760811b6044820152606401610696565b5050505050565b6109f561114e565b600755565b60606001805461057790611b12565b600b8054610a1690611b12565b80601f0160208091040260200160405190810160405280929190818152602001828054610a4290611b12565b8015610a8f5780601f10610a6457610100808354040283529160200191610a8f565b820191906000526020600020905b815481529060010190602001808311610a7257829003601f168201915b505050505081565b60085460ff16610adf5760405162461bcd60e51b81526020600482015260136024820152722a34329039b0b6329034b9903830bab9b2b21760691b6044820152606401610696565b6001811115610b465760405162461bcd60e51b815260206004820152602d60248201527f596f752063616e6e6f74206d696e742074686174206d616e7920696e206f6e6560448201526c103a3930b739b0b1ba34b7b71760991b6064820152608401610696565b336000908152600a6020526040902054600190610b64908390611bf1565b1115610bb25760405162461bcd60e51b815260206004820152601f60248201527f596f752063616e206f6e6c79206d696e742031207065722077616c6c65742e006044820152606401610696565b6009546032610bc18383611bf1565b1115610c075760405162461bcd60e51b815260206004820152601560248201527422bc31b2b2b239903a37ba30b61039bab838363c9760591b6044820152606401610696565b3460075483610c169190611bb0565b1115610c5a5760405162461bcd60e51b815260206004820152601360248201527224b739bab33334b1b4b2b73a10333ab732399760691b6044820152606401610696565b60015b828111610c8757610c7733610c728385611bf1565b6111fa565b610c8081611c09565b9050610c5d565b50336000908152600a602052604081208054849290610ca7908490611bf1565b925050819055508160096000828254610cc09190611bf1565b90915550505050565b610cd161114e565b8051610ce490600b906020840190611765565b5050565b610ce4338383611214565b610cfd3383610f6b565b610d195760405162461bcd60e51b815260040161069690611b4d565b610d25848484846112e3565b50505050565b600c8054610a1690611b12565b6000818152600260205260409020546060906001600160a01b0316610db75760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b6064820152608401610696565b6000610dc1611316565b90506000815111610de15760405180602001604052806000815250610e0f565b80610deb84611325565b600c604051602001610dff93929190611c24565b6040516020818303038152906040525b9392505050565b610e1e61114e565b6001600160a01b038116610e835760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610696565b610e8c816111a8565b50565b6001600160a01b03163b151590565b6000818152600260205260409020546001600160a01b0316610e8c5760405162461bcd60e51b8152602060048201526018602482015277115490cdcc8c4e881a5b9d985b1a59081d1bdad95b88125160421b6044820152606401610696565b600081815260046020526040902080546001600160a01b0319166001600160a01b0384169081179091558190610f32826107a4565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600080610f77836107a4565b9050806001600160a01b0316846001600160a01b03161480610fbe57506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff165b80610fe25750836001600160a01b0316610fd7846105fa565b6001600160a01b0316145b949350505050565b826001600160a01b0316610ffd826107a4565b6001600160a01b0316146110235760405162461bcd60e51b815260040161069690611ce8565b6001600160a01b0382166110855760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b6064820152608401610696565b826001600160a01b0316611098826107a4565b6001600160a01b0316146110be5760405162461bcd60e51b815260040161069690611ce8565b600081815260046020908152604080832080546001600160a01b03199081169091556001600160a01b0387811680865260038552838620805460001901905590871680865283862080546001019055868652600290945282852080549092168417909155905184937fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b6006546001600160a01b0316331461089c5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610696565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b610ce48282604051806020016040528060008152506113c2565b816001600160a01b0316836001600160a01b031614156112765760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c6572000000000000006044820152606401610696565b6001600160a01b03838116600081815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6112ee848484610fea565b6112fa848484846113f5565b610d255760405162461bcd60e51b815260040161069690611d2d565b6060600b805461057790611b12565b6060600061133283611502565b600101905060008167ffffffffffffffff81111561135257611352611952565b6040519080825280601f01601f19166020018201604052801561137c576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a85049450846113b5576113ba565b611386565b509392505050565b6113cc83836115da565b6113d960008484846113f5565b6107375760405162461bcd60e51b815260040161069690611d2d565b60006001600160a01b0384163b156114f757604051630a85bd0160e11b81526001600160a01b0385169063150b7a0290611439903390899088908890600401611d7f565b602060405180830381600087803b15801561145357600080fd5b505af1925050508015611483575060408051601f3d908101601f1916820190925261148091810190611dbc565b60015b6114dd573d8080156114b1576040519150601f19603f3d011682016040523d82523d6000602084013e6114b6565b606091505b5080516114d55760405162461bcd60e51b815260040161069690611d2d565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050610fe2565b506001949350505050565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106115415772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef8100000000831061156d576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061158b57662386f26fc10000830492506010015b6305f5e10083106115a3576305f5e100830492506008015b61271083106115b757612710830492506004015b606483106115c9576064830492506002015b600a83106105625760010192915050565b6001600160a01b0382166116305760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f20616464726573736044820152606401610696565b6000818152600260205260409020546001600160a01b0316156116955760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606401610696565b6000818152600260205260409020546001600160a01b0316156116fa5760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006044820152606401610696565b6001600160a01b038216600081815260036020908152604080832080546001019055848352600290915280822080546001600160a01b0319168417905551839291907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b82805461177190611b12565b90600052602060002090601f01602090048101928261179357600085556117d9565b82601f106117ac57805160ff19168380011785556117d9565b828001600101855582156117d9579182015b828111156117d95782518255916020019190600101906117be565b506117e59291506117e9565b5090565b5b808211156117e557600081556001016117ea565b6001600160e01b031981168114610e8c57600080fd5b60006020828403121561182657600080fd5b8135610e0f816117fe565b60005b8381101561184c578181015183820152602001611834565b83811115610d255750506000910152565b60008151808452611875816020860160208601611831565b601f01601f19169290920160200192915050565b602081526000610e0f602083018461185d565b6000602082840312156118ae57600080fd5b5035919050565b80356001600160a01b03811681146118cc57600080fd5b919050565b600080604083850312156118e457600080fd5b6118ed836118b5565b946020939093013593505050565b60008060006060848603121561191057600080fd5b611919846118b5565b9250611927602085016118b5565b9150604084013590509250925092565b60006020828403121561194957600080fd5b610e0f826118b5565b634e487b7160e01b600052604160045260246000fd5b600067ffffffffffffffff8084111561198357611983611952565b604051601f8501601f19908116603f011681019082821181831017156119ab576119ab611952565b816040528093508581528686860111156119c457600080fd5b858560208301376000602087830101525050509392505050565b6000602082840312156119f057600080fd5b813567ffffffffffffffff811115611a0757600080fd5b8201601f81018413611a1857600080fd5b610fe284823560208401611968565b60008060408385031215611a3a57600080fd5b611a43836118b5565b915060208301358015158114611a5857600080fd5b809150509250929050565b60008060008060808587031215611a7957600080fd5b611a82856118b5565b9350611a90602086016118b5565b925060408501359150606085013567ffffffffffffffff811115611ab357600080fd5b8501601f81018713611ac457600080fd5b611ad387823560208401611968565b91505092959194509250565b60008060408385031215611af257600080fd5b611afb836118b5565b9150611b09602084016118b5565b90509250929050565b600181811c90821680611b2657607f821691505b60208210811415611b4757634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252602d908201527f4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e6560408201526c1c881bdc88185c1c1c9bdd9959609a1b606082015260800190565b634e487b7160e01b600052601160045260246000fd5b6000816000190483118215151615611bca57611bca611b9a565b500290565b600082611bec57634e487b7160e01b600052601260045260246000fd5b500490565b60008219821115611c0457611c04611b9a565b500190565b6000600019821415611c1d57611c1d611b9a565b5060010190565b600084516020611c378285838a01611831565b855191840191611c4a8184848a01611831565b8554920191600090600181811c9080831680611c6757607f831692505b858310811415611c8557634e487b7160e01b85526022600452602485fd5b808015611c995760018114611caa57611cd7565b60ff19851688528388019550611cd7565b60008b81526020902060005b85811015611ccf5781548a820152908401908801611cb6565b505083880195505b50939b9a5050505050505050505050565b60208082526025908201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060408201526437bbb732b960d91b606082015260800190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090611db29083018461185d565b9695505050505050565b600060208284031215611dce57600080fd5b8151610e0f816117fe56fea264697066735822122010b2b0da6d34136e7ec037f3f16c9632314ace14160983bd3865f77fdbbfff4f64736f6c634300080900334552433732313a207472616e7366657220746f206e6f6e204552433732315265697066733a2f2f6261666b726569646d61697471376b64786b357732667273346a616a65356d6964376b6e71336f3777376268356b69756d636e7836716670673569

Deployed Bytecode

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

Deployed Bytecode Sourcemap

56677:2878:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38060:305;;;;;;;;;;-1:-1:-1;38060:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;38060:305:0;;;;;;;;38988:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;40500:171::-;;;;;;;;;;-1:-1:-1;40500:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;40500:171:0;1528:203:1;40018:416:0;;;;;;;;;;-1:-1:-1;40018:416:0;;;;;:::i;:::-;;:::i;:::-;;56970:26;;;;;;;;;;;;;;;;;;;2319:25:1;;;2307:2;2292:18;56970:26:0;2173:177:1;41200:301:0;;;;;;;;;;-1:-1:-1;41200:301:0;;;;;:::i;:::-;;:::i;58227:91::-;;;;;;;;;;;;;:::i;41572:151::-;;;;;;;;;;-1:-1:-1;41572:151:0;;;;;:::i;:::-;;:::i;56939:24::-;;;;;;;;;;-1:-1:-1;56939:24:0;;;;;;;;38698:223;;;;;;;;;;-1:-1:-1;38698:223:0;;;;;:::i;:::-;;:::i;38429:207::-;;;;;;;;;;-1:-1:-1;38429:207:0;;;;;:::i;:::-;;:::i;55789:103::-;;;;;;;;;;;;;:::i;58528:502::-;;;:::i;55148:87::-;;;;;;;;;;-1:-1:-1;55221:6:0;;-1:-1:-1;;;;;55221:6:0;55148:87;;56887:43;;;;;;;;;;;;56929:1;56887:43;;58434:86;;;;;;;;;;-1:-1:-1;58434:86:0;;;;;:::i;:::-;;:::i;39157:104::-;;;;;;;;;;;;;:::i;57063:21::-;;;;;;;;;;;;;:::i;56844:36::-;;;;;;;;;;;;;;;;57462:728;;;;;;:::i;:::-;;:::i;58326:100::-;;;;;;;;;;-1:-1:-1;58326:100:0;;;;;:::i;:::-;;:::i;40743:155::-;;;;;;;;;;-1:-1:-1;40743:155:0;;;;;:::i;:::-;;:::i;41794:279::-;;;;;;;;;;-1:-1:-1;41794:279:0;;;;;:::i;:::-;;:::i;57091:37::-;;;;;;;;;;;;;:::i;59038:397::-;;;;;;;;;;-1:-1:-1;59038:397:0;;;;;:::i;:::-;;:::i;40969:164::-;;;;;;;;;;-1:-1:-1;40969:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;41090:25:0;;;41066:4;41090:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;40969:164;56047:201;;;;;;;;;;-1:-1:-1;56047:201:0;;;;;:::i;:::-;;:::i;56753:36::-;;;;;;;;;;;;56787:2;56753:36;;38060:305;38162:4;-1:-1:-1;;;;;;38199:40:0;;-1:-1:-1;;;38199:40:0;;:105;;-1:-1:-1;;;;;;;38256:48:0;;-1:-1:-1;;;38256:48:0;38199:105;:158;;;-1:-1:-1;;;;;;;;;;29900:40:0;;;38321:36;38179:178;38060:305;-1:-1:-1;;38060:305:0:o;38988:100::-;39042:13;39075:5;39068:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38988:100;:::o;40500:171::-;40576:7;40596:23;40611:7;40596:14;:23::i;:::-;-1:-1:-1;40639:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;40639:24:0;;40500:171::o;40018:416::-;40099:13;40115:23;40130:7;40115:14;:23::i;:::-;40099:39;;40163:5;-1:-1:-1;;;;;40157:11:0;:2;-1:-1:-1;;;;;40157:11:0;;;40149:57;;;;-1:-1:-1;;;40149:57:0;;5980:2:1;40149:57:0;;;5962:21:1;6019:2;5999:18;;;5992:30;6058:34;6038:18;;;6031:62;-1:-1:-1;;;6109:18:1;;;6102:31;6150:19;;40149:57:0;;;;;;;;;36519:10;-1:-1:-1;;;;;40241:21:0;;;;:62;;-1:-1:-1;40266:37:0;40283:5;36519:10;40969:164;:::i;40266:37::-;40219:173;;;;-1:-1:-1;;;40219:173:0;;6382:2:1;40219:173:0;;;6364:21:1;6421:2;6401:18;;;6394:30;6460:34;6440:18;;;6433:62;6531:31;6511:18;;;6504:59;6580:19;;40219:173:0;6180:425:1;40219:173:0;40405:21;40414:2;40418:7;40405:8;:21::i;:::-;40088:346;40018:416;;:::o;41200:301::-;41361:41;36519:10;41394:7;41361:18;:41::i;:::-;41353:99;;;;-1:-1:-1;;;41353:99:0;;;;;;;:::i;:::-;41465:28;41475:4;41481:2;41485:7;41465:9;:28::i;58227:91::-;55034:13;:11;:13::i;:::-;58298:12:::1;::::0;;-1:-1:-1;;58282:28:0;::::1;58298:12;::::0;;::::1;58297:13;58282:28;::::0;;58227:91::o;41572:151::-;41676:39;41693:4;41699:2;41703:7;41676:39;;;;;;;;;;;;:16;:39::i;38698:223::-;38770:7;43431:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43431:16:0;;38834:56;;;;-1:-1:-1;;;38834:56:0;;7226:2:1;38834:56:0;;;7208:21:1;7265:2;7245:18;;;7238:30;-1:-1:-1;;;7284:18:1;;;7277:54;7348:18;;38834:56:0;7024:348:1;38429:207:0;38501:7;-1:-1:-1;;;;;38529:19:0;;38521:73;;;;-1:-1:-1;;;38521:73:0;;7579:2:1;38521:73:0;;;7561:21:1;7618:2;7598:18;;;7591:30;7657:34;7637:18;;;7630:62;-1:-1:-1;;;7708:18:1;;;7701:39;7757:19;;38521:73:0;7377:405:1;38521:73:0;-1:-1:-1;;;;;;38612:16:0;;;;;:9;:16;;;;;;;38429:207::o;55789:103::-;55034:13;:11;:13::i;:::-;55854:30:::1;55881:1;55854:18;:30::i;:::-;55789:103::o:0;58528:502::-;55034:13;:11;:13::i;:::-;58607:21:::1;58589:15;58675:3;58660:12;58607:21:::0;58670:2:::1;58660:12;:::i;:::-;:18;;;;:::i;:::-;58639:39:::0;-1:-1:-1;58689:18:0::1;58725:3;58710:12;:7:::0;58720:2:::1;58710:12;:::i;:::-;:18;;;;:::i;:::-;58763:79;::::0;58689:39;;-1:-1:-1;58741:16:0::1;::::0;58771:42:::1;::::0;58827:10;;58741:16;58763:79;58741:16;58763:79;58827:10;58771:42;58763:79:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;58877:79:0::1;::::0;58739:103;;-1:-1:-1;58855:16:0::1;::::0;58885:42:::1;::::0;58941:10;;58855:16;58877:79;58855:16;58877:79;58941:10;58885:42;58877:79:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58853:103;;;58975:11;:26;;;;;58990:11;58975:26;58967:55;;;::::0;-1:-1:-1;;;58967:55:0;;8858:2:1;58967:55:0::1;::::0;::::1;8840:21:1::0;8897:2;8877:18;;;8870:30;-1:-1:-1;;;8916:18:1;;;8909:46;8972:18;;58967:55:0::1;8656:340:1::0;58967:55:0::1;58578:452;;;;;58528:502::o:0;58434:86::-;55034:13;:11;:13::i;:::-;58498:5:::1;:14:::0;58434:86::o;39157:104::-;39213:13;39246:7;39239:14;;;;;:::i;57063:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57462:728::-;57532:12;;;;57524:44;;;;-1:-1:-1;;;57524:44:0;;9203:2:1;57524:44:0;;;9185:21:1;9242:2;9222:18;;;9215:30;-1:-1:-1;;;9261:18:1;;;9254:49;9320:18;;57524:44:0;9001:343:1;57524:44:0;56929:1;57587:10;:29;;57579:87;;;;-1:-1:-1;;;57579:87:0;;9551:2:1;57579:87:0;;;9533:21:1;9590:2;9570:18;;;9563:30;9629:34;9609:18;;;9602:62;-1:-1:-1;;;9680:18:1;;;9673:43;9733:19;;57579:87:0;9349:409:1;57579:87:0;57701:10;57685:27;;;;:15;:27;;;;;;57729:1;;57685:40;;57715:10;;57685:40;:::i;:::-;:45;;57677:89;;;;-1:-1:-1;;;57677:89:0;;10098:2:1;57677:89:0;;;10080:21:1;10137:2;10117:18;;;10110:30;10176:33;10156:18;;;10149:61;10227:18;;57677:89:0;9896:355:1;57677:89:0;57802:11;;56787:2;57832:27;57849:10;57802:11;57832:27;:::i;:::-;:41;;57824:75;;;;-1:-1:-1;;;57824:75:0;;10458:2:1;57824:75:0;;;10440:21:1;10497:2;10477:18;;;10470:30;-1:-1:-1;;;10516:18:1;;;10509:51;10577:18;;57824:75:0;10256:345:1;57824:75:0;57940:9;57931:5;;57918:10;:18;;;;:::i;:::-;:31;;57910:63;;;;-1:-1:-1;;;57910:63:0;;10808:2:1;57910:63:0;;;10790:21:1;10847:2;10827:18;;;10820:30;-1:-1:-1;;;10866:18:1;;;10859:49;10925:18;;57910:63:0;10606:343:1;57910:63:0;58002:1;57986:109;58010:10;58005:1;:15;57986:109;;58042:41;58052:10;58064:18;58081:1;58064:14;:18;:::i;:::-;58042:9;:41::i;:::-;58022:3;;;:::i;:::-;;;57986:109;;;-1:-1:-1;58121:10:0;58105:27;;;;:15;:27;;;;;:41;;58136:10;;58105:27;:41;;58136:10;;58105:41;:::i;:::-;;;;;;;;58172:10;58157:11;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;57462:728:0:o;58326:100::-;55034:13;:11;:13::i;:::-;58400:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;58326:100:::0;:::o;40743:155::-;40838:52;36519:10;40871:8;40881;40838:18;:52::i;41794:279::-;41925:41;36519:10;41958:7;41925:18;:41::i;:::-;41917:99;;;;-1:-1:-1;;;41917:99:0;;;;;;;:::i;:::-;42027:38;42041:4;42047:2;42051:7;42060:4;42027:13;:38::i;:::-;41794:279;;;;:::o;57091:37::-;;;;;;;:::i;59038:397::-;43833:4;43431:16;;;:7;:16;;;;;;59111:13;;-1:-1:-1;;;;;43431:16:0;59137:76;;;;-1:-1:-1;;;59137:76:0;;11296:2:1;59137:76:0;;;11278:21:1;11335:2;11315:18;;;11308:30;11374:34;11354:18;;;11347:62;-1:-1:-1;;;11425:18:1;;;11418:45;11480:19;;59137:76:0;11094:411:1;59137:76:0;59227:28;59258:10;:8;:10::i;:::-;59227:41;;59317:1;59292:14;59286:28;:32;:141;;;;;;;;;;;;;;;;;59358:14;59374:18;:7;:16;:18::i;:::-;59394:13;59341:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59286:141;59279:148;59038:397;-1:-1:-1;;;59038:397:0:o;56047:201::-;55034:13;:11;:13::i;:::-;-1:-1:-1;;;;;56136:22:0;::::1;56128:73;;;::::0;-1:-1:-1;;;56128:73:0;;13370:2:1;56128:73:0::1;::::0;::::1;13352:21:1::0;13409:2;13389:18;;;13382:30;13448:34;13428:18;;;13421:62;-1:-1:-1;;;13499:18:1;;;13492:36;13545:19;;56128:73:0::1;13168:402:1::0;56128:73:0::1;56212:28;56231:8;56212:18;:28::i;:::-;56047:201:::0;:::o;18796:326::-;-1:-1:-1;;;;;19091:19:0;;:23;;;18796:326::o;50063:135::-;43833:4;43431:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43431:16:0;50137:53;;;;-1:-1:-1;;;50137:53:0;;7226:2:1;50137:53:0;;;7208:21:1;7265:2;7245:18;;;7238:30;-1:-1:-1;;;7284:18:1;;;7277:54;7348:18;;50137:53:0;7024:348:1;49376:174:0;49451:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;49451:29:0;-1:-1:-1;;;;;49451:29:0;;;;;;;;:24;;49505:23;49451:24;49505:14;:23::i;:::-;-1:-1:-1;;;;;49496:46:0;;;;;;;;;;;49376:174;;:::o;44063:264::-;44156:4;44173:13;44189:23;44204:7;44189:14;:23::i;:::-;44173:39;;44242:5;-1:-1:-1;;;;;44231:16:0;:7;-1:-1:-1;;;;;44231:16:0;;:52;;;-1:-1:-1;;;;;;41090:25:0;;;41066:4;41090:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;44251:32;44231:87;;;;44311:7;-1:-1:-1;;;;;44287:31:0;:20;44299:7;44287:11;:20::i;:::-;-1:-1:-1;;;;;44287:31:0;;44231:87;44223:96;44063:264;-1:-1:-1;;;;44063:264:0:o;48028:1229::-;48153:4;-1:-1:-1;;;;;48126:31:0;:23;48141:7;48126:14;:23::i;:::-;-1:-1:-1;;;;;48126:31:0;;48118:81;;;;-1:-1:-1;;;48118:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48218:16:0;;48210:65;;;;-1:-1:-1;;;48210:65:0;;14183:2:1;48210:65:0;;;14165:21:1;14222:2;14202:18;;;14195:30;14261:34;14241:18;;;14234:62;-1:-1:-1;;;14312:18:1;;;14305:34;14356:19;;48210:65:0;13981:400:1;48210:65:0;48460:4;-1:-1:-1;;;;;48433:31:0;:23;48448:7;48433:14;:23::i;:::-;-1:-1:-1;;;;;48433:31:0;;48425:81;;;;-1:-1:-1;;;48425:81:0;;;;;;;:::i;:::-;48578:24;;;;:15;:24;;;;;;;;48571:31;;-1:-1:-1;;;;;;48571:31:0;;;;;;-1:-1:-1;;;;;49054:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;49054:20:0;;;49089:13;;;;;;;;;:18;;48571:31;49089:18;;;49129:16;;;:7;:16;;;;;;:21;;;;;;;;;;49168:27;;48594:7;;49168:27;;;40088:346;40018:416;;:::o;55313:132::-;55221:6;;-1:-1:-1;;;;;55221:6:0;36519:10;55377:23;55369:68;;;;-1:-1:-1;;;55369:68:0;;14588:2:1;55369:68:0;;;14570:21:1;;;14607:18;;;14600:30;14666:34;14646:18;;;14639:62;14718:18;;55369:68:0;14386:356:1;56408:191:0;56501:6;;;-1:-1:-1;;;;;56518:17:0;;;-1:-1:-1;;;;;;56518:17:0;;;;;;;56551:40;;56501:6;;;56518:17;56501:6;;56551:40;;56482:16;;56551:40;56471:128;56408:191;:::o;44669:110::-;44745:26;44755:2;44759:7;44745:26;;;;;;;;;;;;:9;:26::i;49693:281::-;49814:8;-1:-1:-1;;;;;49805:17:0;:5;-1:-1:-1;;;;;49805:17:0;;;49797:55;;;;-1:-1:-1;;;49797:55:0;;14949:2:1;49797:55:0;;;14931:21:1;14988:2;14968:18;;;14961:30;15027:27;15007:18;;;15000:55;15072:18;;49797:55:0;14747:349:1;49797:55:0;-1:-1:-1;;;;;49863:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;49863:46:0;;;;;;;;;;49925:41;;540::1;;;49925::0;;513:18:1;49925:41:0;;;;;;;49693:281;;;:::o;42954:270::-;43067:28;43077:4;43083:2;43087:7;43067:9;:28::i;:::-;43114:47;43137:4;43143:2;43147:7;43156:4;43114:22;:47::i;:::-;43106:110;;;;-1:-1:-1;;;43106:110:0;;;;;;;:::i;59444:108::-;59504:13;59537:7;59530:14;;;;;:::i;14920:716::-;14976:13;15027:14;15044:17;15055:5;15044:10;:17::i;:::-;15064:1;15044:21;15027:38;;15080:20;15114:6;15103:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15103:18:0;-1:-1:-1;15080:41:0;-1:-1:-1;15245:28:0;;;15261:2;15245:28;15302:288;-1:-1:-1;;15334:5:0;-1:-1:-1;;;15471:2:0;15460:14;;15455:30;15334:5;15442:44;15532:2;15523:11;;;-1:-1:-1;15557:10:0;15553:21;;15569:5;;15553:21;15302:288;;;-1:-1:-1;15611:6:0;14920:716;-1:-1:-1;;;14920:716:0:o;45006:285::-;45101:18;45107:2;45111:7;45101:5;:18::i;:::-;45152:53;45183:1;45187:2;45191:7;45200:4;45152:22;:53::i;:::-;45130:153;;;;-1:-1:-1;;;45130:153:0;;;;;;;:::i;50762:853::-;50916:4;-1:-1:-1;;;;;50937:13:0;;19091:19;:23;50933:675;;50973:71;;-1:-1:-1;;;50973:71:0;;-1:-1:-1;;;;;50973:36:0;;;;;:71;;36519:10;;51024:4;;51030:7;;51039:4;;50973:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50973:71:0;;;;;;;;-1:-1:-1;;50973:71:0;;;;;;;;;;;;:::i;:::-;;;50969:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51214:13:0;;51210:328;;51257:60;;-1:-1:-1;;;51257:60:0;;;;;;;:::i;51210:328::-;51488:6;51482:13;51473:6;51469:2;51465:15;51458:38;50969:584;-1:-1:-1;;;;;;51095:51:0;-1:-1:-1;;;51095:51:0;;-1:-1:-1;51088:58:0;;50933:675;-1:-1:-1;51592:4:0;50762:853;;;;;;:::o;11754:948::-;11807:7;;-1:-1:-1;;;11885:17:0;;11881:106;;-1:-1:-1;;;11923:17:0;;;-1:-1:-1;11969:2:0;11959:12;11881:106;12014:8;12005:5;:17;12001:106;;12052:8;12043:17;;;-1:-1:-1;12089:2:0;12079:12;12001:106;12134:8;12125:5;:17;12121:106;;12172:8;12163:17;;;-1:-1:-1;12209:2:0;12199:12;12121:106;12254:7;12245:5;:16;12241:103;;12291:7;12282:16;;;-1:-1:-1;12327:1:0;12317:11;12241:103;12371:7;12362:5;:16;12358:103;;12408:7;12399:16;;;-1:-1:-1;12444:1:0;12434:11;12358:103;12488:7;12479:5;:16;12475:103;;12525:7;12516:16;;;-1:-1:-1;12561:1:0;12551:11;12475:103;12605:7;12596:5;:16;12592:68;;12643:1;12633:11;12688:6;11754:948;-1:-1:-1;;11754:948:0:o;45627:942::-;-1:-1:-1;;;;;45707:16:0;;45699:61;;;;-1:-1:-1;;;45699:61:0;;16470:2:1;45699:61:0;;;16452:21:1;;;16489:18;;;16482:30;16548:34;16528:18;;;16521:62;16600:18;;45699:61:0;16268:356:1;45699:61:0;43833:4;43431:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43431:16:0;43857:31;45771:58;;;;-1:-1:-1;;;45771:58:0;;16831:2:1;45771:58:0;;;16813:21:1;16870:2;16850:18;;;16843:30;16909;16889:18;;;16882:58;16957:18;;45771:58:0;16629:352:1;45771:58:0;43833:4;43431:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43431:16:0;43857:31;45980:58;;;;-1:-1:-1;;;45980:58:0;;16831:2:1;45980:58:0;;;16813:21:1;16870:2;16850:18;;;16843:30;16909;16889:18;;;16882:58;16957:18;;45980:58:0;16629:352:1;45980:58:0;-1:-1:-1;;;;;46387:13:0;;;;;;:9;:13;;;;;;;;:18;;46404:1;46387:18;;;46429:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;46429:21:0;;;;;46468:33;46437:7;;46387:13;;46468:33;;46387:13;;46468:33;58400:18:::1;58326:100:::0;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2355:328::-;2432:6;2440;2448;2501:2;2489:9;2480:7;2476:23;2472:32;2469:52;;;2517:1;2514;2507:12;2469:52;2540:29;2559:9;2540:29;:::i;:::-;2530:39;;2588:38;2622:2;2611:9;2607:18;2588:38;:::i;:::-;2578:48;;2673:2;2662:9;2658:18;2645:32;2635:42;;2355:328;;;;;:::o;2688:186::-;2747:6;2800:2;2788:9;2779:7;2775:23;2771:32;2768:52;;;2816:1;2813;2806:12;2768:52;2839:29;2858:9;2839:29;:::i;2879:127::-;2940:10;2935:3;2931:20;2928:1;2921:31;2971:4;2968:1;2961:15;2995:4;2992:1;2985:15;3011:632;3076:5;3106:18;3147:2;3139:6;3136:14;3133:40;;;3153:18;;:::i;:::-;3228:2;3222:9;3196:2;3282:15;;-1:-1:-1;;3278:24:1;;;3304:2;3274:33;3270:42;3258:55;;;3328:18;;;3348:22;;;3325:46;3322:72;;;3374:18;;:::i;:::-;3414:10;3410:2;3403:22;3443:6;3434:15;;3473:6;3465;3458:22;3513:3;3504:6;3499:3;3495:16;3492:25;3489:45;;;3530:1;3527;3520:12;3489:45;3580:6;3575:3;3568:4;3560:6;3556:17;3543:44;3635:1;3628:4;3619:6;3611;3607:19;3603:30;3596:41;;;;3011:632;;;;;:::o;3648:451::-;3717:6;3770:2;3758:9;3749:7;3745:23;3741:32;3738:52;;;3786:1;3783;3776:12;3738:52;3826:9;3813:23;3859:18;3851:6;3848:30;3845:50;;;3891:1;3888;3881:12;3845:50;3914:22;;3967:4;3959:13;;3955:27;-1:-1:-1;3945:55:1;;3996:1;3993;3986:12;3945:55;4019:74;4085:7;4080:2;4067:16;4062:2;4058;4054:11;4019:74;:::i;4104:347::-;4169:6;4177;4230:2;4218:9;4209:7;4205:23;4201:32;4198:52;;;4246:1;4243;4236:12;4198:52;4269:29;4288:9;4269:29;:::i;:::-;4259:39;;4348:2;4337:9;4333:18;4320:32;4395:5;4388:13;4381:21;4374:5;4371:32;4361:60;;4417:1;4414;4407:12;4361:60;4440:5;4430:15;;;4104:347;;;;;:::o;4456:667::-;4551:6;4559;4567;4575;4628:3;4616:9;4607:7;4603:23;4599:33;4596:53;;;4645:1;4642;4635:12;4596:53;4668:29;4687:9;4668:29;:::i;:::-;4658:39;;4716:38;4750:2;4739:9;4735:18;4716:38;:::i;:::-;4706:48;;4801:2;4790:9;4786:18;4773:32;4763:42;;4856:2;4845:9;4841:18;4828:32;4883:18;4875:6;4872:30;4869:50;;;4915:1;4912;4905:12;4869:50;4938:22;;4991:4;4983:13;;4979:27;-1:-1:-1;4969:55:1;;5020:1;5017;5010:12;4969:55;5043:74;5109:7;5104:2;5091:16;5086:2;5082;5078:11;5043:74;:::i;:::-;5033:84;;;4456:667;;;;;;;:::o;5128:260::-;5196:6;5204;5257:2;5245:9;5236:7;5232:23;5228:32;5225:52;;;5273:1;5270;5263:12;5225:52;5296:29;5315:9;5296:29;:::i;:::-;5286:39;;5344:38;5378:2;5367:9;5363:18;5344:38;:::i;:::-;5334:48;;5128:260;;;;;:::o;5393:380::-;5472:1;5468:12;;;;5515;;;5536:61;;5590:4;5582:6;5578:17;5568:27;;5536:61;5643:2;5635:6;5632:14;5612:18;5609:38;5606:161;;;5689:10;5684:3;5680:20;5677:1;5670:31;5724:4;5721:1;5714:15;5752:4;5749:1;5742:15;5606:161;;5393:380;;;:::o;6610:409::-;6812:2;6794:21;;;6851:2;6831:18;;;6824:30;6890:34;6885:2;6870:18;;6863:62;-1:-1:-1;;;6956:2:1;6941:18;;6934:43;7009:3;6994:19;;6610:409::o;7787:127::-;7848:10;7843:3;7839:20;7836:1;7829:31;7879:4;7876:1;7869:15;7903:4;7900:1;7893:15;7919:168;7959:7;8025:1;8021;8017:6;8013:14;8010:1;8007:21;8002:1;7995:9;7988:17;7984:45;7981:71;;;8032:18;;:::i;:::-;-1:-1:-1;8072:9:1;;7919:168::o;8224:217::-;8264:1;8290;8280:132;;8334:10;8329:3;8325:20;8322:1;8315:31;8369:4;8366:1;8359:15;8397:4;8394:1;8387:15;8280:132;-1:-1:-1;8426:9:1;;8224:217::o;9763:128::-;9803:3;9834:1;9830:6;9827:1;9824:13;9821:39;;;9840:18;;:::i;:::-;-1:-1:-1;9876:9:1;;9763:128::o;10954:135::-;10993:3;-1:-1:-1;;11014:17:1;;11011:43;;;11034:18;;:::i;:::-;-1:-1:-1;11081:1:1;11070:13;;10954:135::o;11636:1527::-;11860:3;11898:6;11892:13;11924:4;11937:51;11981:6;11976:3;11971:2;11963:6;11959:15;11937:51;:::i;:::-;12051:13;;12010:16;;;;12073:55;12051:13;12010:16;12095:15;;;12073:55;:::i;:::-;12217:13;;12150:20;;;12190:1;;12277;12299:18;;;;12352;;;;12379:93;;12457:4;12447:8;12443:19;12431:31;;12379:93;12520:2;12510:8;12507:16;12487:18;12484:40;12481:167;;;-1:-1:-1;;;12547:33:1;;12603:4;12600:1;12593:15;12633:4;12554:3;12621:17;12481:167;12664:18;12691:110;;;;12815:1;12810:328;;;;12657:481;;12691:110;-1:-1:-1;;12726:24:1;;12712:39;;12771:20;;;;-1:-1:-1;12691:110:1;;12810:328;11583:1;11576:14;;;11620:4;11607:18;;12905:1;12919:169;12933:8;12930:1;12927:15;12919:169;;;13015:14;;13000:13;;;12993:37;13058:16;;;;12950:10;;12919:169;;;12923:3;;13119:8;13112:5;13108:20;13101:27;;12657:481;-1:-1:-1;13154:3:1;;11636:1527;-1:-1:-1;;;;;;;;;;;11636:1527:1:o;13575:401::-;13777:2;13759:21;;;13816:2;13796:18;;;13789:30;13855:34;13850:2;13835:18;;13828:62;-1:-1:-1;;;13921:2:1;13906:18;;13899:35;13966:3;13951:19;;13575:401::o;15101:414::-;15303:2;15285:21;;;15342:2;15322:18;;;15315:30;15381:34;15376:2;15361:18;;15354:62;-1:-1:-1;;;15447:2:1;15432:18;;15425:48;15505:3;15490:19;;15101:414::o;15520:489::-;-1:-1:-1;;;;;15789:15:1;;;15771:34;;15841:15;;15836:2;15821:18;;15814:43;15888:2;15873:18;;15866:34;;;15936:3;15931:2;15916:18;;15909:31;;;15714:4;;15957:46;;15983:19;;15975:6;15957:46;:::i;:::-;15949:54;15520:489;-1:-1:-1;;;;;;15520:489:1:o;16014:249::-;16083:6;16136:2;16124:9;16115:7;16111:23;16107:32;16104:52;;;16152:1;16149;16142:12;16104:52;16184:9;16178:16;16203:30;16227:5;16203:30;:::i

Swarm Source

ipfs://10b2b0da6d34136e7ec037f3f16c9632314ace14160983bd3865f77fdbbfff4f

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services