Token

ERC-1155

Overview

Max Total Supply

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x2034d0c3961424aee4964300277cbf5ffa864d78

Filtered by Token Holder

0x682e7dd7b9bE59674AA948549AD4EdaBE833920F

0x682e7dd7b9be59674aa948549ad4edabe833920f

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SlowlyFadingQuietly

Compiler Version

v0.8.20+commit.a1b79de6

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-06-10
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

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

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol


// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the value of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;


/**
 * @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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the 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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                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.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol)

pragma solidity ^0.8.20;



/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }
}

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// File: @openzeppelin/contracts/token/ERC1155/ERC1155.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.20;








/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 */
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors {
    using Arrays for uint256[];
    using Arrays for address[];

    mapping(uint256 id => mapping(address account => uint256)) private _balances;

    mapping(address account => mapping(address operator => bool)) private _operatorApprovals;

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256 /* id */) public view virtual returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     */
    function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    ) public view virtual returns (uint256[] memory) {
        if (accounts.length != ids.length) {
            revert ERC1155InvalidArrayLength(ids.length, accounts.length);
        }

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i));
        }

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeTransferFrom(from, to, id, value, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeBatchTransferFrom(from, to, ids, values, data);
    }

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from`
     * (or `to`) is the zero address.
     *
     * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received}
     *   or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
     * - `ids` and `values` must have the same length.
     *
     * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead.
     */
    function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual {
        if (ids.length != values.length) {
            revert ERC1155InvalidArrayLength(ids.length, values.length);
        }

        address operator = _msgSender();

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids.unsafeMemoryAccess(i);
            uint256 value = values.unsafeMemoryAccess(i);

            if (from != address(0)) {
                uint256 fromBalance = _balances[id][from];
                if (fromBalance < value) {
                    revert ERC1155InsufficientBalance(from, fromBalance, value, id);
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance
                    _balances[id][from] = fromBalance - value;
                }
            }

            if (to != address(0)) {
                _balances[id][to] += value;
            }
        }

        if (ids.length == 1) {
            uint256 id = ids.unsafeMemoryAccess(0);
            uint256 value = values.unsafeMemoryAccess(0);
            emit TransferSingle(operator, from, to, id, value);
        } else {
            emit TransferBatch(operator, from, to, ids, values);
        }
    }

    /**
     * @dev Version of {_update} that performs the token acceptance check by calling
     * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it
     * contains code (eg. is a smart contract at the moment of execution).
     *
     * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any
     * update to the contract state after this function would break the check-effect-interaction pattern. Consider
     * overriding {_update} instead.
     */
    function _updateWithAcceptanceCheck(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal virtual {
        _update(from, to, ids, values);
        if (to != address(0)) {
            address operator = _msgSender();
            if (ids.length == 1) {
                uint256 id = ids.unsafeMemoryAccess(0);
                uint256 value = values.unsafeMemoryAccess(0);
                _doSafeTransferAcceptanceCheck(operator, from, to, id, value, data);
            } else {
                _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, values, data);
            }
        }
    }

    /**
     * @dev Transfers a `value` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     * - `ids` and `values` must have the same length.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the values in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

    /**
     * @dev Destroys a `value` amount of tokens of type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     */
    function _burn(address from, uint256 id, uint256 value) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     * - `ids` and `values` must have the same length.
     */
    function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the zero address.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC1155InvalidOperator(address(0));
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Performs an acceptance check by calling {IERC1155-onERC1155Received} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Performs a batch acceptance check by calling {IERC1155-onERC1155BatchReceived} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Creates an array in memory with only one value for each of the elements provided.
     */
    function _asSingletonArrays(
        uint256 element1,
        uint256 element2
    ) private pure returns (uint256[] memory array1, uint256[] memory array2) {
        /// @solidity memory-safe-assembly
        assembly {
            // Load the free memory pointer
            array1 := mload(0x40)
            // Set array length to 1
            mstore(array1, 1)
            // Store the single element at the next word after the length (where content starts)
            mstore(add(array1, 0x20), element1)

            // Repeat for next array locating it right after the first array
            array2 := add(array1, 0x40)
            mstore(array2, 1)
            mstore(add(array2, 0x20), element2)

            // Update the free memory pointer by pointing after the second array
            mstore(0x40, add(array2, 0x40))
        }
    }
}

// File: contracts/sc.sol


pragma solidity ^0.8.20;


contract SlowlyFadingQuietly is ERC1155 {
    uint256 public constant TOKEN1 = 1;
    uint256 public constant TOKEN2 = 2;
    uint256 public constant TOKEN3 = 3;

    uint256 public deploymentTime;

    // Initial metadata URIs (fading)
    string private _fadingURI1 = "ipfs://QmRrUB7h6c4UNUCJoNaEkijXpgE274Qsu489eN1aVEmMSC";
    string private _fadingURI2 = "ipfs://QmTMms3bQdDGHbdxcTv26m4uxwcQNafV3mBd2ZWSfkEdVt";
    string private _fadingURI3 = "ipfs://QmaQp1G7rG4TWosfsGwAxFby5yEukVpa1Kp5rLPNm9SqS2";

    // Final metadata URIs to be used after 8 years
    string private _finalURI1 = "ipfs://QmQgkrdu9RjAGCaSTZ4HnfyqCv8TU799i1WrZ5cm5ucn4A";
    string private _finalURI2 = "ipfs://QmaVWsM7gnSvgfGaCdjztpWvmL9ZjDrH31xBFTGmYHmLmu";
    string private _finalURI3 = "ipfs://QmPogXJrNawWJvyf8wV9VtNTcJuD6fmUZEt3tbQAh729T1";

    constructor() ERC1155("") {
        deploymentTime = block.timestamp;
        
        // Mint initial tokens to the contract deployer
        _mint(msg.sender, TOKEN1, 1, "");
        _mint(msg.sender, TOKEN2, 1, "");
        _mint(msg.sender, TOKEN3, 1, "");
    }

    function uri(uint256 tokenId) public view override returns (string memory) {
        require(tokenId >= TOKEN1 && tokenId <= TOKEN3, "Invalid token ID");

        if (block.timestamp >= deploymentTime + 8 * 365 days) {
            if (tokenId == TOKEN1) return _finalURI1;
            if (tokenId == TOKEN2) return _finalURI2;
            if (tokenId == TOKEN3) return _finalURI3;
        } else {
            if (tokenId == TOKEN1) return _fadingURI1;
            if (tokenId == TOKEN2) return _fadingURI2;
            if (tokenId == TOKEN3) return _fadingURI3;
        }

        revert("Invalid token ID");
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"TOKEN1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN3","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deploymentTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

59497:1762:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44344:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43453:310;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59626:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60627:629;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46167:441;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44644:567;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59544:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45284:146;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59585:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45502:159;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59669:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45733:357;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44344:134;44421:7;44448:9;:13;44458:2;44448:13;;;;;;;;;;;:22;44462:7;44448:22;;;;;;;;;;;;;;;;44441:29;;44344:134;;;;:::o;43453:310::-;43555:4;43607:26;43592:41;;;:11;:41;;;;:110;;;;43665:37;43650:52;;;:11;:52;;;;43592:110;:163;;;;43719:36;43743:11;43719:23;:36::i;:::-;43592:163;43572:183;;43453:310;;;:::o;59626:34::-;59659:1;59626:34;:::o;60627:629::-;60687:13;59577:1;60721:7;:17;;:38;;;;;59659:1;60742:7;:17;;60721:38;60713:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;60833:12;60816:14;;:29;;;;:::i;:::-;60797:15;:48;60793:417;;59577:1;60866:7;:17;60862:40;;60892:10;60885:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60862:40;59618:1;60921:7;:17;60917:40;;60947:10;60940:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60917:40;59659:1;60976:7;:17;60972:40;;61002:10;60995:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60972:40;60793:417;;;59577:1;61049:7;:17;61045:41;;61075:11;61068:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61045:41;59618:1;61105:7;:17;61101:41;;61131:11;61124:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61101:41;59659:1;61161:7;:17;61157:41;;61187:11;61180:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61157:41;60793:417;61222:26;;;;;;;;;;:::i;:::-;;;;;;;;60627:629;;;;:::o;46167:441::-;46368:14;46385:12;:10;:12::i;:::-;46368:29;;46420:6;46412:14;;:4;:14;;;;:49;;;;;46431:30;46448:4;46454:6;46431:16;:30::i;:::-;46430:31;46412:49;46408:131;;;46514:6;46522:4;46485:42;;;;;;;;;;;;:::i;:::-;;;;;;;;46408:131;46549:51;46572:4;46578:2;46582:3;46587:6;46595:4;46549:22;:51::i;:::-;46357:251;46167:441;;;;;:::o;44644:567::-;44771:16;44823:3;:10;44804:8;:15;:29;44800:123;;44883:3;:10;44895:8;:15;44857:54;;;;;;;;;;;;:::i;:::-;;;;;;;;44800:123;44935:30;44982:8;:15;44968:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44935:63;;45016:9;45011:160;45035:8;:15;45031:1;:19;45011:160;;;45091:68;45101:30;45129:1;45101:8;:27;;:30;;;;:::i;:::-;45133:25;45156:1;45133:3;:22;;:25;;;;:::i;:::-;45091:9;:68::i;:::-;45072:13;45086:1;45072:16;;;;;;;;:::i;:::-;;;;;;;:87;;;;;45052:3;;;;:::i;:::-;;;45011:160;;;;45190:13;45183:20;;;44644:567;;;;:::o;59544:34::-;59577:1;59544:34;:::o;45284:146::-;45370:52;45389:12;:10;:12::i;:::-;45403:8;45413;45370:18;:52::i;:::-;45284:146;;:::o;59585:34::-;59618:1;59585:34;:::o;45502:159::-;45592:4;45616:18;:27;45635:7;45616:27;;;;;;;;;;;;;;;:37;45644:8;45616:37;;;;;;;;;;;;;;;;;;;;;;;;;45609:44;;45502:159;;;;:::o;59669:29::-;;;;:::o;45733:357::-;45857:14;45874:12;:10;:12::i;:::-;45857:29;;45909:6;45901:14;;:4;:14;;;;:49;;;;;45920:30;45937:4;45943:6;45920:16;:30::i;:::-;45919:31;45901:49;45897:131;;;46003:6;46011:4;45974:42;;;;;;;;;;;;:::i;:::-;;;;;;;;45897:131;46038:44;46056:4;46062:2;46066;46070:5;46077:4;46038:17;:44::i;:::-;45846:244;45733:357;;;;;:::o;10995:148::-;11071:4;11110:25;11095:40;;;:11;:40;;;;11088:47;;10995:148;;;:::o;9893:98::-;9946:7;9973:10;9966:17;;9893:98;:::o;51295:459::-;51509:1;51495:16;;:2;:16;;;51491:90;;51566:1;51535:34;;;;;;;;;;;:::i;:::-;;;;;;;;51491:90;51611:1;51595:18;;:4;:18;;;51591:90;;51666:1;51637:32;;;;;;;;;;;:::i;:::-;;;;;;;;51591:90;51691:55;51718:4;51724:2;51728:3;51733:6;51741:4;51691:26;:55::i;:::-;51295:459;;;;;:::o;35466:201::-;35552:11;35642:4;35637:3;35633:14;35626:4;35621:3;35617:14;35613:35;35607:42;35600:49;;35466:201;;;;:::o;35056:::-;35142:11;35232:4;35227:3;35223:14;35216:4;35211:3;35207:14;35203:35;35197:42;35190:49;;35056:201;;;;:::o;55670:321::-;55798:1;55778:22;;:8;:22;;;55774:96;;55855:1;55824:34;;;;;;;;;;;:::i;:::-;;;;;;;;55774:96;55918:8;55880:18;:25;55899:5;55880:25;;;;;;;;;;;;;;;:35;55906:8;55880:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;55964:8;55942:41;;55957:5;55942:41;;;55974:8;55942:41;;;;;;:::i;:::-;;;;;;;;55670:321;;;:::o;50409:472::-;50546:1;50532:16;;:2;:16;;;50528:90;;50603:1;50572:34;;;;;;;;;;;:::i;:::-;;;;;;;;50528:90;50648:1;50632:18;;:4;:18;;;50628:90;;50703:1;50674:32;;;;;;;;;;;:::i;:::-;;;;;;;;50628:90;50729:20;50751:23;50778:29;50797:2;50801:5;50778:18;:29::i;:::-;50728:79;;;;50818:55;50845:4;50851:2;50855:3;50860:6;50868:4;50818:26;:55::i;:::-;50517:364;;50409:472;;;;;:::o;49230:708::-;49438:30;49446:4;49452:2;49456:3;49461:6;49438:7;:30::i;:::-;49497:1;49483:16;;:2;:16;;;49479:452;;49516:16;49535:12;:10;:12::i;:::-;49516:31;;49580:1;49566:3;:10;:15;49562:358;;49602:10;49615:25;49638:1;49615:3;:22;;:25;;;;:::i;:::-;49602:38;;49659:13;49675:28;49701:1;49675:6;:25;;:28;;;;:::i;:::-;49659:44;;49722:67;49753:8;49763:4;49769:2;49773;49777:5;49784:4;49722:30;:67::i;:::-;49583:222;;49562:358;;;49830:74;49866:8;49876:4;49882:2;49886:3;49891:6;49899:4;49830:35;:74::i;:::-;49562:358;49501:430;49479:452;49230:708;;;;;:::o;58559:870::-;58670:23;58695;58860:4;58854:11;58844:21;;58932:1;58924:6;58917:17;59072:8;59065:4;59057:6;59053:17;59046:35;59197:4;59189:6;59185:17;59175:27;;59231:1;59223:6;59216:17;59273:8;59266:4;59258:6;59254:17;59247:35;59405:4;59397:6;59393:17;59387:4;59380:31;58559:870;;;;;:::o;47325:1315::-;47461:6;:13;47447:3;:10;:27;47443:119;;47524:3;:10;47536:6;:13;47498:52;;;;;;;;;;;;:::i;:::-;;;;;;;;47443:119;47574:16;47593:12;:10;:12::i;:::-;47574:31;;47623:9;47618:709;47642:3;:10;47638:1;:14;47618:709;;;47674:10;47687:25;47710:1;47687:3;:22;;:25;;;;:::i;:::-;47674:38;;47727:13;47743:28;47769:1;47743:6;:25;;:28;;;;:::i;:::-;47727:44;;47808:1;47792:18;;:4;:18;;;47788:429;;47831:19;47853:9;:13;47863:2;47853:13;;;;;;;;;;;:19;47867:4;47853:19;;;;;;;;;;;;;;;;47831:41;;47909:5;47895:11;:19;47891:131;;;47973:4;47979:11;47992:5;47999:2;47946:56;;;;;;;;;;;;;;:::i;:::-;;;;;;;;47891:131;48177:5;48163:11;:19;48141:9;:13;48151:2;48141:13;;;;;;;;;;;:19;48155:4;48141:19;;;;;;;;;;;;;;;:41;;;;47812:405;47788:429;48251:1;48237:16;;:2;:16;;;48233:83;;48295:5;48274:9;:13;48284:2;48274:13;;;;;;;;;;;:17;48288:2;48274:17;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;48233:83;47659:668;;47654:3;;;;:::i;:::-;;;47618:709;;;;48357:1;48343:3;:10;:15;48339:294;;48375:10;48388:25;48411:1;48388:3;:22;;:25;;;;:::i;:::-;48375:38;;48428:13;48444:28;48470:1;48444:6;:25;;:28;;;;:::i;:::-;48428:44;;48523:2;48492:45;;48517:4;48492:45;;48507:8;48492:45;;;48527:2;48531:5;48492:45;;;;;;;:::i;:::-;;;;;;;;48360:189;;48339:294;;;48605:2;48575:46;;48599:4;48575:46;;48589:8;48575:46;;;48609:3;48614:6;48575:46;;;;;;;:::i;:::-;;;;;;;;48339:294;47432:1208;47325:1315;;;;:::o;56175:1000::-;56406:1;56389:2;:14;;;:18;56385:783;;;56445:2;56428:38;;;56467:8;56477:4;56483:2;56487:5;56494:4;56428:71;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;56424:733;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56806:1;56789:6;:13;:18;56785:357;;56918:2;56895:26;;;;;;;;;;;:::i;:::-;;;;;;;;56785:357;57092:6;57086:13;57077:6;57073:2;57069:15;57062:38;56424:733;56561:43;;;56549:55;;;:8;:55;;;;56545:177;;56699:2;56676:26;;;;;;;;;;;:::i;:::-;;;;;;;;56545:177;56500:237;56385:783;56175:1000;;;;;;:::o;57369:1069::-;57625:1;57608:2;:14;;;:18;57604:827;;;57664:2;57647:43;;;57691:8;57701:4;57707:3;57712:6;57720:4;57647:78;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;57643:777;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58069:1;58052:6;:13;:18;58048:357;;58181:2;58158:26;;;;;;;;;;;:::i;:::-;;;;;;;;58048:357;58355:6;58349:13;58340:6;58336:2;58332:15;58325:38;57643:777;57819:48;;;57807:60;;;:8;:60;;;;57803:182;;57962:2;57939:26;;;;;;;;;;;:::i;:::-;;;;;;;;57803:182;57726:274;57604:827;57369:1069;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:474::-;1265:6;1273;1322:2;1310:9;1301:7;1297:23;1293:32;1290:119;;;1328:79;;:::i;:::-;1290:119;1448:1;1473:53;1518:7;1509:6;1498:9;1494:22;1473:53;:::i;:::-;1463:63;;1419:117;1575:2;1601:53;1646:7;1637:6;1626:9;1622:22;1601:53;:::i;:::-;1591:63;;1546:118;1197:474;;;;;:::o;1677:118::-;1764:24;1782:5;1764:24;:::i;:::-;1759:3;1752:37;1677:118;;:::o;1801:222::-;1894:4;1932:2;1921:9;1917:18;1909:26;;1945:71;2013:1;2002:9;1998:17;1989:6;1945:71;:::i;:::-;1801:222;;;;:::o;2029:149::-;2065:7;2105:66;2098:5;2094:78;2083:89;;2029:149;;;:::o;2184:120::-;2256:23;2273:5;2256:23;:::i;:::-;2249:5;2246:34;2236:62;;2294:1;2291;2284:12;2236:62;2184:120;:::o;2310:137::-;2355:5;2393:6;2380:20;2371:29;;2409:32;2435:5;2409:32;:::i;:::-;2310:137;;;;:::o;2453:327::-;2511:6;2560:2;2548:9;2539:7;2535:23;2531:32;2528:119;;;2566:79;;:::i;:::-;2528:119;2686:1;2711:52;2755:7;2746:6;2735:9;2731:22;2711:52;:::i;:::-;2701:62;;2657:116;2453:327;;;;:::o;2786:90::-;2820:7;2863:5;2856:13;2849:21;2838:32;;2786:90;;;:::o;2882:109::-;2963:21;2978:5;2963:21;:::i;:::-;2958:3;2951:34;2882:109;;:::o;2997:210::-;3084:4;3122:2;3111:9;3107:18;3099:26;;3135:65;3197:1;3186:9;3182:17;3173:6;3135:65;:::i;:::-;2997:210;;;;:::o;3213:329::-;3272:6;3321:2;3309:9;3300:7;3296:23;3292:32;3289:119;;;3327:79;;:::i;:::-;3289:119;3447:1;3472:53;3517:7;3508:6;3497:9;3493:22;3472:53;:::i;:::-;3462:63;;3418:117;3213:329;;;;:::o;3548:99::-;3600:6;3634:5;3628:12;3618:22;;3548:99;;;:::o;3653:169::-;3737:11;3771:6;3766:3;3759:19;3811:4;3806:3;3802:14;3787:29;;3653:169;;;;:::o;3828:246::-;3909:1;3919:113;3933:6;3930:1;3927:13;3919:113;;;4018:1;4013:3;4009:11;4003:18;3999:1;3994:3;3990:11;3983:39;3955:2;3952:1;3948:10;3943:15;;3919:113;;;4066:1;4057:6;4052:3;4048:16;4041:27;3890:184;3828:246;;;:::o;4080:102::-;4121:6;4172:2;4168:7;4163:2;4156:5;4152:14;4148:28;4138:38;;4080:102;;;:::o;4188:377::-;4276:3;4304:39;4337:5;4304:39;:::i;:::-;4359:71;4423:6;4418:3;4359:71;:::i;:::-;4352:78;;4439:65;4497:6;4492:3;4485:4;4478:5;4474:16;4439:65;:::i;:::-;4529:29;4551:6;4529:29;:::i;:::-;4524:3;4520:39;4513:46;;4280:285;4188:377;;;;:::o;4571:313::-;4684:4;4722:2;4711:9;4707:18;4699:26;;4771:9;4765:4;4761:20;4757:1;4746:9;4742:17;4735:47;4799:78;4872:4;4863:6;4799:78;:::i;:::-;4791:86;;4571:313;;;;:::o;4890:117::-;4999:1;4996;4989:12;5013:180;5061:77;5058:1;5051:88;5158:4;5155:1;5148:15;5182:4;5179:1;5172:15;5199:281;5282:27;5304:4;5282:27;:::i;:::-;5274:6;5270:40;5412:6;5400:10;5397:22;5376:18;5364:10;5361:34;5358:62;5355:88;;;5423:18;;:::i;:::-;5355:88;5463:10;5459:2;5452:22;5242:238;5199:281;;:::o;5486:129::-;5520:6;5547:20;;:::i;:::-;5537:30;;5576:33;5604:4;5596:6;5576:33;:::i;:::-;5486:129;;;:::o;5621:311::-;5698:4;5788:18;5780:6;5777:30;5774:56;;;5810:18;;:::i;:::-;5774:56;5860:4;5852:6;5848:17;5840:25;;5920:4;5914;5910:15;5902:23;;5621:311;;;:::o;5938:117::-;6047:1;6044;6037:12;6078:710;6174:5;6199:81;6215:64;6272:6;6215:64;:::i;:::-;6199:81;:::i;:::-;6190:90;;6300:5;6329:6;6322:5;6315:21;6363:4;6356:5;6352:16;6345:23;;6416:4;6408:6;6404:17;6396:6;6392:30;6445:3;6437:6;6434:15;6431:122;;;6464:79;;:::i;:::-;6431:122;6579:6;6562:220;6596:6;6591:3;6588:15;6562:220;;;6671:3;6700:37;6733:3;6721:10;6700:37;:::i;:::-;6695:3;6688:50;6767:4;6762:3;6758:14;6751:21;;6638:144;6622:4;6617:3;6613:14;6606:21;;6562:220;;;6566:21;6180:608;;6078:710;;;;;:::o;6811:370::-;6882:5;6931:3;6924:4;6916:6;6912:17;6908:27;6898:122;;6939:79;;:::i;:::-;6898:122;7056:6;7043:20;7081:94;7171:3;7163:6;7156:4;7148:6;7144:17;7081:94;:::i;:::-;7072:103;;6888:293;6811:370;;;;:::o;7187:117::-;7296:1;7293;7286:12;7310:307;7371:4;7461:18;7453:6;7450:30;7447:56;;;7483:18;;:::i;:::-;7447:56;7521:29;7543:6;7521:29;:::i;:::-;7513:37;;7605:4;7599;7595:15;7587:23;;7310:307;;;:::o;7623:146::-;7720:6;7715:3;7710;7697:30;7761:1;7752:6;7747:3;7743:16;7736:27;7623:146;;;:::o;7775:423::-;7852:5;7877:65;7893:48;7934:6;7893:48;:::i;:::-;7877:65;:::i;:::-;7868:74;;7965:6;7958:5;7951:21;8003:4;7996:5;7992:16;8041:3;8032:6;8027:3;8023:16;8020:25;8017:112;;;8048:79;;:::i;:::-;8017:112;8138:54;8185:6;8180:3;8175;8138:54;:::i;:::-;7858:340;7775:423;;;;;:::o;8217:338::-;8272:5;8321:3;8314:4;8306:6;8302:17;8298:27;8288:122;;8329:79;;:::i;:::-;8288:122;8446:6;8433:20;8471:78;8545:3;8537:6;8530:4;8522:6;8518:17;8471:78;:::i;:::-;8462:87;;8278:277;8217:338;;;;:::o;8561:1509::-;8715:6;8723;8731;8739;8747;8796:3;8784:9;8775:7;8771:23;8767:33;8764:120;;;8803:79;;:::i;:::-;8764:120;8923:1;8948:53;8993:7;8984:6;8973:9;8969:22;8948:53;:::i;:::-;8938:63;;8894:117;9050:2;9076:53;9121:7;9112:6;9101:9;9097:22;9076:53;:::i;:::-;9066:63;;9021:118;9206:2;9195:9;9191:18;9178:32;9237:18;9229:6;9226:30;9223:117;;;9259:79;;:::i;:::-;9223:117;9364:78;9434:7;9425:6;9414:9;9410:22;9364:78;:::i;:::-;9354:88;;9149:303;9519:2;9508:9;9504:18;9491:32;9550:18;9542:6;9539:30;9536:117;;;9572:79;;:::i;:::-;9536:117;9677:78;9747:7;9738:6;9727:9;9723:22;9677:78;:::i;:::-;9667:88;;9462:303;9832:3;9821:9;9817:19;9804:33;9864:18;9856:6;9853:30;9850:117;;;9886:79;;:::i;:::-;9850:117;9991:62;10045:7;10036:6;10025:9;10021:22;9991:62;:::i;:::-;9981:72;;9775:288;8561:1509;;;;;;;;:::o;10076:311::-;10153:4;10243:18;10235:6;10232:30;10229:56;;;10265:18;;:::i;:::-;10229:56;10315:4;10307:6;10303:17;10295:25;;10375:4;10369;10365:15;10357:23;;10076:311;;;:::o;10410:710::-;10506:5;10531:81;10547:64;10604:6;10547:64;:::i;:::-;10531:81;:::i;:::-;10522:90;;10632:5;10661:6;10654:5;10647:21;10695:4;10688:5;10684:16;10677:23;;10748:4;10740:6;10736:17;10728:6;10724:30;10777:3;10769:6;10766:15;10763:122;;;10796:79;;:::i;:::-;10763:122;10911:6;10894:220;10928:6;10923:3;10920:15;10894:220;;;11003:3;11032:37;11065:3;11053:10;11032:37;:::i;:::-;11027:3;11020:50;11099:4;11094:3;11090:14;11083:21;;10970:144;10954:4;10949:3;10945:14;10938:21;;10894:220;;;10898:21;10512:608;;10410:710;;;;;:::o;11143:370::-;11214:5;11263:3;11256:4;11248:6;11244:17;11240:27;11230:122;;11271:79;;:::i;:::-;11230:122;11388:6;11375:20;11413:94;11503:3;11495:6;11488:4;11480:6;11476:17;11413:94;:::i;:::-;11404:103;;11220:293;11143:370;;;;:::o;11519:894::-;11637:6;11645;11694:2;11682:9;11673:7;11669:23;11665:32;11662:119;;;11700:79;;:::i;:::-;11662:119;11848:1;11837:9;11833:17;11820:31;11878:18;11870:6;11867:30;11864:117;;;11900:79;;:::i;:::-;11864:117;12005:78;12075:7;12066:6;12055:9;12051:22;12005:78;:::i;:::-;11995:88;;11791:302;12160:2;12149:9;12145:18;12132:32;12191:18;12183:6;12180:30;12177:117;;;12213:79;;:::i;:::-;12177:117;12318:78;12388:7;12379:6;12368:9;12364:22;12318:78;:::i;:::-;12308:88;;12103:303;11519:894;;;;;:::o;12419:114::-;12486:6;12520:5;12514:12;12504:22;;12419:114;;;:::o;12539:184::-;12638:11;12672:6;12667:3;12660:19;12712:4;12707:3;12703:14;12688:29;;12539:184;;;;:::o;12729:132::-;12796:4;12819:3;12811:11;;12849:4;12844:3;12840:14;12832:22;;12729:132;;;:::o;12867:108::-;12944:24;12962:5;12944:24;:::i;:::-;12939:3;12932:37;12867:108;;:::o;12981:179::-;13050:10;13071:46;13113:3;13105:6;13071:46;:::i;:::-;13149:4;13144:3;13140:14;13126:28;;12981:179;;;;:::o;13166:113::-;13236:4;13268;13263:3;13259:14;13251:22;;13166:113;;;:::o;13315:732::-;13434:3;13463:54;13511:5;13463:54;:::i;:::-;13533:86;13612:6;13607:3;13533:86;:::i;:::-;13526:93;;13643:56;13693:5;13643:56;:::i;:::-;13722:7;13753:1;13738:284;13763:6;13760:1;13757:13;13738:284;;;13839:6;13833:13;13866:63;13925:3;13910:13;13866:63;:::i;:::-;13859:70;;13952:60;14005:6;13952:60;:::i;:::-;13942:70;;13798:224;13785:1;13782;13778:9;13773:14;;13738:284;;;13742:14;14038:3;14031:10;;13439:608;;;13315:732;;;;:::o;14053:373::-;14196:4;14234:2;14223:9;14219:18;14211:26;;14283:9;14277:4;14273:20;14269:1;14258:9;14254:17;14247:47;14311:108;14414:4;14405:6;14311:108;:::i;:::-;14303:116;;14053:373;;;;:::o;14432:116::-;14502:21;14517:5;14502:21;:::i;:::-;14495:5;14492:32;14482:60;;14538:1;14535;14528:12;14482:60;14432:116;:::o;14554:133::-;14597:5;14635:6;14622:20;14613:29;;14651:30;14675:5;14651:30;:::i;:::-;14554:133;;;;:::o;14693:468::-;14758:6;14766;14815:2;14803:9;14794:7;14790:23;14786:32;14783:119;;;14821:79;;:::i;:::-;14783:119;14941:1;14966:53;15011:7;15002:6;14991:9;14987:22;14966:53;:::i;:::-;14956:63;;14912:117;15068:2;15094:50;15136:7;15127:6;15116:9;15112:22;15094:50;:::i;:::-;15084:60;;15039:115;14693:468;;;;;:::o;15167:474::-;15235:6;15243;15292:2;15280:9;15271:7;15267:23;15263:32;15260:119;;;15298:79;;:::i;:::-;15260:119;15418:1;15443:53;15488:7;15479:6;15468:9;15464:22;15443:53;:::i;:::-;15433:63;;15389:117;15545:2;15571:53;15616:7;15607:6;15596:9;15592:22;15571:53;:::i;:::-;15561:63;;15516:118;15167:474;;;;;:::o;15647:1089::-;15751:6;15759;15767;15775;15783;15832:3;15820:9;15811:7;15807:23;15803:33;15800:120;;;15839:79;;:::i;:::-;15800:120;15959:1;15984:53;16029:7;16020:6;16009:9;16005:22;15984:53;:::i;:::-;15974:63;;15930:117;16086:2;16112:53;16157:7;16148:6;16137:9;16133:22;16112:53;:::i;:::-;16102:63;;16057:118;16214:2;16240:53;16285:7;16276:6;16265:9;16261:22;16240:53;:::i;:::-;16230:63;;16185:118;16342:2;16368:53;16413:7;16404:6;16393:9;16389:22;16368:53;:::i;:::-;16358:63;;16313:118;16498:3;16487:9;16483:19;16470:33;16530:18;16522:6;16519:30;16516:117;;;16552:79;;:::i;:::-;16516:117;16657:62;16711:7;16702:6;16691:9;16687:22;16657:62;:::i;:::-;16647:72;;16441:288;15647:1089;;;;;;;;:::o;16742:166::-;16882:18;16878:1;16870:6;16866:14;16859:42;16742:166;:::o;16914:366::-;17056:3;17077:67;17141:2;17136:3;17077:67;:::i;:::-;17070:74;;17153:93;17242:3;17153:93;:::i;:::-;17271:2;17266:3;17262:12;17255:19;;16914:366;;;:::o;17286:419::-;17452:4;17490:2;17479:9;17475:18;17467:26;;17539:9;17533:4;17529:20;17525:1;17514:9;17510:17;17503:47;17567:131;17693:4;17567:131;:::i;:::-;17559:139;;17286:419;;;:::o;17711:180::-;17759:77;17756:1;17749:88;17856:4;17853:1;17846:15;17880:4;17877:1;17870:15;17897:191;17937:3;17956:20;17974:1;17956:20;:::i;:::-;17951:25;;17990:20;18008:1;17990:20;:::i;:::-;17985:25;;18033:1;18030;18026:9;18019:16;;18054:3;18051:1;18048:10;18045:36;;;18061:18;;:::i;:::-;18045:36;17897:191;;;;:::o;18094:180::-;18142:77;18139:1;18132:88;18239:4;18236:1;18229:15;18263:4;18260:1;18253:15;18280:320;18324:6;18361:1;18355:4;18351:12;18341:22;;18408:1;18402:4;18398:12;18429:18;18419:81;;18485:4;18477:6;18473:17;18463:27;;18419:81;18547:2;18539:6;18536:14;18516:18;18513:38;18510:84;;18566:18;;:::i;:::-;18510:84;18331:269;18280:320;;;:::o;18606:118::-;18693:24;18711:5;18693:24;:::i;:::-;18688:3;18681:37;18606:118;;:::o;18730:332::-;18851:4;18889:2;18878:9;18874:18;18866:26;;18902:71;18970:1;18959:9;18955:17;18946:6;18902:71;:::i;:::-;18983:72;19051:2;19040:9;19036:18;19027:6;18983:72;:::i;:::-;18730:332;;;;;:::o;19068:::-;19189:4;19227:2;19216:9;19212:18;19204:26;;19240:71;19308:1;19297:9;19293:17;19284:6;19240:71;:::i;:::-;19321:72;19389:2;19378:9;19374:18;19365:6;19321:72;:::i;:::-;19068:332;;;;;:::o;19406:180::-;19454:77;19451:1;19444:88;19551:4;19548:1;19541:15;19575:4;19572:1;19565:15;19592:233;19631:3;19654:24;19672:5;19654:24;:::i;:::-;19645:33;;19700:66;19693:5;19690:77;19687:103;;19770:18;;:::i;:::-;19687:103;19817:1;19810:5;19806:13;19799:20;;19592:233;;;:::o;19831:222::-;19924:4;19962:2;19951:9;19947:18;19939:26;;19975:71;20043:1;20032:9;20028:17;20019:6;19975:71;:::i;:::-;19831:222;;;;:::o;20059:553::-;20236:4;20274:3;20263:9;20259:19;20251:27;;20288:71;20356:1;20345:9;20341:17;20332:6;20288:71;:::i;:::-;20369:72;20437:2;20426:9;20422:18;20413:6;20369:72;:::i;:::-;20451;20519:2;20508:9;20504:18;20495:6;20451:72;:::i;:::-;20533;20601:2;20590:9;20586:18;20577:6;20533:72;:::i;:::-;20059:553;;;;;;;:::o;20618:634::-;20839:4;20877:2;20866:9;20862:18;20854:26;;20926:9;20920:4;20916:20;20912:1;20901:9;20897:17;20890:47;20954:108;21057:4;21048:6;20954:108;:::i;:::-;20946:116;;21109:9;21103:4;21099:20;21094:2;21083:9;21079:18;21072:48;21137:108;21240:4;21231:6;21137:108;:::i;:::-;21129:116;;20618:634;;;;;:::o;21258:98::-;21309:6;21343:5;21337:12;21327:22;;21258:98;;;:::o;21362:168::-;21445:11;21479:6;21474:3;21467:19;21519:4;21514:3;21510:14;21495:29;;21362:168;;;;:::o;21536:373::-;21622:3;21650:38;21682:5;21650:38;:::i;:::-;21704:70;21767:6;21762:3;21704:70;:::i;:::-;21697:77;;21783:65;21841:6;21836:3;21829:4;21822:5;21818:16;21783:65;:::i;:::-;21873:29;21895:6;21873:29;:::i;:::-;21868:3;21864:39;21857:46;;21626:283;21536:373;;;;:::o;21915:751::-;22138:4;22176:3;22165:9;22161:19;22153:27;;22190:71;22258:1;22247:9;22243:17;22234:6;22190:71;:::i;:::-;22271:72;22339:2;22328:9;22324:18;22315:6;22271:72;:::i;:::-;22353;22421:2;22410:9;22406:18;22397:6;22353:72;:::i;:::-;22435;22503:2;22492:9;22488:18;22479:6;22435:72;:::i;:::-;22555:9;22549:4;22545:20;22539:3;22528:9;22524:19;22517:49;22583:76;22654:4;22645:6;22583:76;:::i;:::-;22575:84;;21915:751;;;;;;;;:::o;22672:141::-;22728:5;22759:6;22753:13;22744:22;;22775:32;22801:5;22775:32;:::i;:::-;22672:141;;;;:::o;22819:349::-;22888:6;22937:2;22925:9;22916:7;22912:23;22908:32;22905:119;;;22943:79;;:::i;:::-;22905:119;23063:1;23088:63;23143:7;23134:6;23123:9;23119:22;23088:63;:::i;:::-;23078:73;;23034:127;22819:349;;;;:::o;23174:1053::-;23497:4;23535:3;23524:9;23520:19;23512:27;;23549:71;23617:1;23606:9;23602:17;23593:6;23549:71;:::i;:::-;23630:72;23698:2;23687:9;23683:18;23674:6;23630:72;:::i;:::-;23749:9;23743:4;23739:20;23734:2;23723:9;23719:18;23712:48;23777:108;23880:4;23871:6;23777:108;:::i;:::-;23769:116;;23932:9;23926:4;23922:20;23917:2;23906:9;23902:18;23895:48;23960:108;24063:4;24054:6;23960:108;:::i;:::-;23952:116;;24116:9;24110:4;24106:20;24100:3;24089:9;24085:19;24078:49;24144:76;24215:4;24206:6;24144:76;:::i;:::-;24136:84;;23174:1053;;;;;;;;:::o

Swarm Source

ipfs://a0681cf498e8897902a73dcca0db2045469bcd4b161bb71972862e61951d95a9

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