// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Arrays.sol)
// This file was procedurally generated from scripts/generate/templates/Arrays.js.

pragma solidity ^0.8.20;

import {Comparators} from "./Comparators.sol";
import {SlotDerivation} from "./SlotDerivation.sol";
import {StorageSlot} from "./StorageSlot.sol";
import {Math} from "./math/Math.sol";

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

    /**
     * @dev Sort an array of uint256 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        uint256[] memory array,
        function(uint256, uint256) pure returns (bool) comp
    ) internal pure returns (uint256[] memory) {
        _quickSort(_begin(array), _end(array), comp);
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of uint256 in increasing order.
     */
    function sort(uint256[] memory array) internal pure returns (uint256[] memory) {
        sort(array, Comparators.lt);
        return array;
    }

    /**
     * @dev Sort an array of address (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        address[] memory array,
        function(address, address) pure returns (bool) comp
    ) internal pure returns (address[] memory) {
        sort(_castToUint256Array(array), _castToUint256Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of address in increasing order.
     */
    function sort(address[] memory array) internal pure returns (address[] memory) {
        sort(_castToUint256Array(array), Comparators.lt);
        return array;
    }

    /**
     * @dev Sort an array of bytes32 (in memory) following the provided comparator function.
     *
     * This function does the sorting "in place", meaning that it overrides the input. The object is returned for
     * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.
     *
     * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the
     * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful
     * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may
     * consume more gas than is available in a block, leading to potential DoS.
     *
     * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way.
     */
    function sort(
        bytes32[] memory array,
        function(bytes32, bytes32) pure returns (bool) comp
    ) internal pure returns (bytes32[] memory) {
        sort(_castToUint256Array(array), _castToUint256Comp(comp));
        return array;
    }

    /**
     * @dev Variant of {sort} that sorts an array of bytes32 in increasing order.
     */
    function sort(bytes32[] memory array) internal pure returns (bytes32[] memory) {
        sort(_castToUint256Array(array), Comparators.lt);
        return array;
    }

    /**
     * @dev Performs a quick sort of a segment of memory. The segment sorted starts at `begin` (inclusive), and stops
     * at end (exclusive). Sorting follows the `comp` comparator.
     *
     * Invariant: `begin <= end`. This is the case when initially called by {sort} and is preserved in subcalls.
     *
     * IMPORTANT: Memory locations between `begin` and `end` are not validated/zeroed. This function should
     * be used only if the limits are within a memory array.
     */
    function _quickSort(uint256 begin, uint256 end, function(uint256, uint256) pure returns (bool) comp) private pure {
        unchecked {
            if (end - begin < 0x40) return;

            // Use first element as pivot
            uint256 pivot = _mload(begin);
            // Position where the pivot should be at the end of the loop
            uint256 pos = begin;

            for (uint256 it = begin + 0x20; it < end; it += 0x20) {
                if (comp(_mload(it), pivot)) {
                    // If the value stored at the iterator's position comes before the pivot, we increment the
                    // position of the pivot and move the value there.
                    pos += 0x20;
                    _swap(pos, it);
                }
            }

            _swap(begin, pos); // Swap pivot into place
            _quickSort(begin, pos, comp); // Sort the left side of the pivot
            _quickSort(pos + 0x20, end, comp); // Sort the right side of the pivot
        }
    }

    /**
     * @dev Pointer to the memory location of the first element of `array`.
     */
    function _begin(uint256[] memory array) private pure returns (uint256 ptr) {
        assembly ("memory-safe") {
            ptr := add(array, 0x20)
        }
    }

    /**
     * @dev Pointer to the memory location of the first memory word (32bytes) after `array`. This is the memory word
     * that comes just after the last element of the array.
     */
    function _end(uint256[] memory array) private pure returns (uint256 ptr) {
        unchecked {
            return _begin(array) + array.length * 0x20;
        }
    }

    /**
     * @dev Load memory word (as a uint256) at location `ptr`.
     */
    function _mload(uint256 ptr) private pure returns (uint256 value) {
        assembly {
            value := mload(ptr)
        }
    }

    /**
     * @dev Swaps the elements memory location `ptr1` and `ptr2`.
     */
    function _swap(uint256 ptr1, uint256 ptr2) private pure {
        assembly {
            let value1 := mload(ptr1)
            let value2 := mload(ptr2)
            mstore(ptr1, value2)
            mstore(ptr2, value1)
        }
    }

    /// @dev Helper: low level cast address memory array to uint256 memory array
    function _castToUint256Array(address[] memory input) private pure returns (uint256[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast bytes32 memory array to uint256 memory array
    function _castToUint256Array(bytes32[] memory input) private pure returns (uint256[] memory output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast address comp function to uint256 comp function
    function _castToUint256Comp(
        function(address, address) pure returns (bool) input
    ) private pure returns (function(uint256, uint256) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /// @dev Helper: low level cast bytes32 comp function to uint256 comp function
    function _castToUint256Comp(
        function(bytes32, bytes32) pure returns (bool) input
    ) private pure returns (function(uint256, uint256) pure returns (bool) output) {
        assembly {
            output := input
        }
    }

    /**
     * @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).
     *
     * NOTE: The `array` is expected to be sorted in ascending order, and to
     * contain no repeated elements.
     *
     * IMPORTANT: Deprecated. This implementation behaves as {lowerBound} but lacks
     * support for repeated elements in the array. The {lowerBound} function should
     * be used instead.
     */
    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 Searches an `array` sorted in ascending order and returns the first
     * index that contains a value greater or equal than `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).
     *
     * See C++'s https://en.cppreference.com/w/cpp/algorithm/lower_bound[lower_bound].
     */
    function lowerBound(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) {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            } else {
                high = mid;
            }
        }

        return low;
    }

    /**
     * @dev Searches an `array` sorted in ascending order and returns the first
     * index that contains a value strictly greater than `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).
     *
     * See C++'s https://en.cppreference.com/w/cpp/algorithm/upper_bound[upper_bound].
     */
    function upperBound(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 {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            }
        }

        return low;
    }

    /**
     * @dev Same as {lowerBound}, but with an array in memory.
     */
    function lowerBoundMemory(uint256[] memory array, uint256 element) internal pure 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 (unsafeMemoryAccess(array, mid) < element) {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            } else {
                high = mid;
            }
        }

        return low;
    }

    /**
     * @dev Same as {upperBound}, but with an array in memory.
     */
    function upperBoundMemory(uint256[] memory array, uint256 element) internal pure 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 (unsafeMemoryAccess(array, mid) > element) {
                high = mid;
            } else {
                // this cannot overflow because mid < high
                unchecked {
                    low = mid + 1;
                }
            }
        }

        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;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).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;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).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;
        assembly ("memory-safe") {
            slot := arr.slot
        }
        return slot.deriveArray().offset(pos).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(address[] memory arr, uint256 pos) internal pure returns (address 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(bytes32[] memory arr, uint256 pos) internal pure returns (bytes32 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(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(address[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(bytes32[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }

    /**
     * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden.
     *
     * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased.
     */
    function unsafeSetLength(uint256[] storage array, uint256 len) internal {
        assembly ("memory-safe") {
            sstore(array.slot, len)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Comparators.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides a set of functions to compare values.
 *
 * _Available since v5.1._
 */
library Comparators {
    function lt(uint256 a, uint256 b) internal pure returns (bool) {
        return a < b;
    }

    function gt(uint256 a, uint256 b) internal pure returns (bool) {
        return a > b;
    }
}

// SPDX-License-Identifier: MIT
// 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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

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

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

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

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

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[ERC-2098 short signatures]
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address recovered, RecoverError err, bytes32 errArg) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

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

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

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

        return (signer, RecoverError.NoError, bytes32(0));
    }

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

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.20;

import {IERC1155} from "./IERC1155.sol";
import {IERC1155MetadataURI} from "./extensions/IERC1155MetadataURI.sol";
import {ERC1155Utils} from "./utils/ERC1155Utils.sol";
import {Context} from "../../utils/Context.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {Arrays} from "../../utils/Arrays.sol";
import {IERC1155Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @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 ERC].
     *
     * 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);
                ERC1155Utils.checkOnERC1155Received(operator, from, to, id, value, data);
            } else {
                ERC1155Utils.checkOnERC1155BatchReceived(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 ERC].
     *
     * 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 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) {
        assembly ("memory-safe") {
            // 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))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/ERC1155Burnable.sol)

pragma solidity ^0.8.20;

import {ERC1155} from "../ERC1155.sol";

/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(address account, uint256 id, uint256 value) public virtual {
        if (account != _msgSender() && !isApprovedForAll(account, _msgSender())) {
            revert ERC1155MissingApprovalForAll(_msgSender(), account);
        }

        _burn(account, id, value);
    }

    function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual {
        if (account != _msgSender() && !isApprovedForAll(account, _msgSender())) {
            revert ERC1155MissingApprovalForAll(_msgSender(), account);
        }

        _burnBatch(account, ids, values);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.20;

import {ERC1155} from "../ERC1155.sol";
import {Arrays} from "../../../utils/Arrays.sol";

/**
 * @dev Extension of ERC-1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 *
 * NOTE: This contract implies a global limit of 2**256 - 1 to the number of tokens
 * that can be minted.
 *
 * CAUTION: This extension should not be added in an upgrade to an already deployed contract.
 */
abstract contract ERC1155Supply is ERC1155 {
    using Arrays for uint256[];

    mapping(uint256 id => uint256) private _totalSupply;
    uint256 private _totalSupplyAll;

    /**
     * @dev Total value of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Total value of tokens.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupplyAll;
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_update}.
     */
    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal virtual override {
        super._update(from, to, ids, values);

        if (from == address(0)) {
            uint256 totalMintValue = 0;
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 value = values.unsafeMemoryAccess(i);
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
                _totalSupply[ids.unsafeMemoryAccess(i)] += value;
                totalMintValue += value;
            }
            // Overflow check required: The rest of the code assumes that totalSupplyAll never overflows
            _totalSupplyAll += totalMintValue;
        }

        if (to == address(0)) {
            uint256 totalBurnValue = 0;
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 value = values.unsafeMemoryAccess(i);

                unchecked {
                    // Overflow not possible: values[i] <= balanceOf(from, ids[i]) <= totalSupply(ids[i])
                    _totalSupply[ids.unsafeMemoryAccess(i)] -= value;
                    // Overflow not possible: sum_i(values[i]) <= sum_i(totalSupply(ids[i])) <= totalSupplyAll
                    totalBurnValue += value;
                }
            }
            unchecked {
                // Overflow not possible: totalBurnValue = sum_i(values[i]) <= sum_i(totalSupply(ids[i])) <= totalSupplyAll
                _totalSupplyAll -= totalBurnValue;
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Utils.sol)

pragma solidity ^0.8.20;

import {IERC1155Receiver} from "../IERC1155Receiver.sol";
import {IERC1155Errors} from "../../../interfaces/draft-IERC6093.sol";

/**
 * @dev Library that provide common ERC-1155 utility functions.
 *
 * See https://eips.ethereum.org/EIPS/eip-1155[ERC-1155].
 *
 * _Available since v5.1._
 */
library ERC1155Utils {
    /**
     * @dev Performs an acceptance check for the provided `operator` by calling {IERC1155-onERC1155Received}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC1155Received(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes memory data
    ) internal {
        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 IERC1155Errors.ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC1155Receiver implementer
                    revert IERC1155Errors.ERC1155InvalidReceiver(to);
                } else {
                    assembly ("memory-safe") {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Performs a batch acceptance check for the provided `operator` by calling {IERC1155-onERC1155BatchReceived}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC1155BatchReceived(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal {
        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 IERC1155Errors.ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC1155Receiver implementer
                    revert IERC1155Errors.ERC1155InvalidReceiver(to);
                } else {
                    assembly ("memory-safe") {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 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;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;

import {IERC721} from "./IERC721.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {ERC721Utils} from "./utils/ERC721Utils.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => 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 returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

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

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

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

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string.concat(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 {
        _approve(to, tokenId, _msgSender());
    }

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

        return _getApproved(tokenId);
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual {
        transferFrom(from, to, tokenId);
        ERC721Utils.checkOnERC721Received(
            _msgSender(),
            from,
            to,
            tokenId,
            data
        );
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is 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`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(
        uint256 tokenId
    ) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(
        address owner,
        address spender,
        uint256 tokenId
    ) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender ||
                isApprovedForAll(owner, spender) ||
                _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if:
     * - `spender` does not have approval from `owner` for `tokenId`.
     * - `spender` does not have approval to manage all of `owner`'s assets.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(
        address owner,
        address spender,
        uint256 tokenId
    ) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * 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 {
        _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);
        ERC721Utils.checkOnERC721Received(
            _msgSender(),
            address(0),
            to,
            tokenId,
            data
        );
    }

    /**
     * @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 {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
    }

    /**
     * @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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC-721 standard 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 like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - 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) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        ERC721Utils.checkOnERC721Received(
            _msgSender(),
            from,
            to,
            tokenId,
            data
        );
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address auth,
        bool emitEvent
    ) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (
                auth != address(0) &&
                owner != auth &&
                !isApprovedForAll(owner, auth)
            ) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

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

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Burnable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {Context} from "../../../utils/Context.sol";

/**
 * @title ERC-721 Burnable Token
 * @dev ERC-721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        _update(address(0), tokenId, _msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {ERC721} from "../ERC721.sol";
import {IERC721Enumerable} from "./IERC721Enumerable.sol";
import {IERC165} from "../../../utils/introspection/ERC165.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the ERC that adds enumerability
 * of all the token ids in the contract as well as all token ids owned by each account.
 *
 * CAUTION: {ERC721} extensions that implement custom `balanceOf` logic, such as {ERC721Consecutive},
 * interfere with enumerability and should not be used together with {ERC721Enumerable}.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
    mapping(uint256 tokenId => uint256) private _ownedTokensIndex;

    uint256[] private _allTokens;
    mapping(uint256 tokenId => uint256) private _allTokensIndex;

    /**
     * @dev An `owner`'s token query was out of bounds for `index`.
     *
     * NOTE: The owner being `address(0)` indicates a global out of bounds index.
     */
    error ERC721OutOfBoundsIndex(address owner, uint256 index);

    /**
     * @dev Batch mint is not allowed.
     */
    error ERC721EnumerableForbiddenBatchMint();

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256) {
        if (index >= balanceOf(owner)) {
            revert ERC721OutOfBoundsIndex(owner, index);
        }
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual returns (uint256) {
        if (index >= totalSupply()) {
            revert ERC721OutOfBoundsIndex(address(0), index);
        }
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_update}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) {
        address previousOwner = super._update(to, tokenId, auth);

        if (previousOwner == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _removeTokenFromOwnerEnumeration(previousOwner, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }

        return previousOwner;
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = balanceOf(to) - 1;
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = balanceOf(from);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        mapping(uint256 index => uint256) storage _ownedTokensByOwner = _ownedTokens[from];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokensByOwner[lastTokenIndex];

            _ownedTokensByOwner[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokensByOwner[lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /**
     * See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch
     */
    function _increaseBalance(address account, uint128 amount) internal virtual override {
        if (amount > 0) {
            revert ERC721EnumerableForbiddenBatchMint();
        }
        super._increaseBalance(account, amount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/utils/ERC721Utils.sol)

pragma solidity ^0.8.20;

import {IERC721Receiver} from "../IERC721Receiver.sol";
import {IERC721Errors} from "../../../interfaces/draft-IERC6093.sol";

/**
 * @dev Library that provide common ERC-721 utility functions.
 *
 * See https://eips.ethereum.org/EIPS/eip-721[ERC-721].
 *
 * _Available since v5.1._
 */
library ERC721Utils {
    /**
     * @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received}
     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
     *
     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
     * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept
     * the transfer.
     */
    function checkOnERC721Received(
        address operator,
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    // Token rejected
                    revert IERC721Errors.ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-IERC721Receiver implementer
                    revert IERC721Errors.ERC721InvalidReceiver(to);
                } else {
                    assembly ("memory-safe") {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC-1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[ERC].
 */
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`.
     */
    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 zero address.
     */
    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;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.20;

import {IERC1155} from "../IERC1155.sol";

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[ERC].
 */
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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * 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[ERC 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC-721 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 ERC-721 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 ERC-721
     * 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 address zero.
     *
     * 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

import {IERC721} from "../IERC721.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC-721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC-721 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);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for generating pseudorandom numbers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibPRNG.sol)
/// @author LazyShuffler based on NextShuffler by aschlosberg (divergencearran)
/// (https://github.com/divergencetech/ethier/blob/main/contracts/random/NextShuffler.sol)
library LibPRNG_01 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The initial length must be greater than zero and less than `2**32 - 1`.
    error InvalidInitialLazyShufflerLength();

    /// @dev The new length must not be less than the current length.
    error InvalidNewLazyShufflerLength();

    /// @dev The lazy shuffler has not been initialized.
    error LazyShufflerNotInitialized();

    /// @dev Cannot double initialize the lazy shuffler.
    error LazyShufflerAlreadyInitialized();

    /// @dev The lazy shuffle has finished.
    error LazyShuffleFinished();

    /// @dev The queried index is out of bounds.
    error LazyShufflerGetOutOfBounds();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The scalar of ETH and most ERC20s.
    uint256 internal constant WAD = 1e18;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A pseudorandom number state in memory.
    struct PRNG {
        uint256 state;
    }

    /// @dev A lazy Fisher-Yates shuffler for a range `[0..n)` in storage.
    struct LazyShuffler {
        // Bits Layout:
        // - [0..31]    `numShuffled`
        // - [32..223]  `permutationSlot`
        // - [224..255] `length`
        uint256 _state;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Seeds the `prng` with `state`.
    function seed(PRNG memory prng, uint256 state) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(prng, state)
        }
    }

    /// @dev Returns the next pseudorandom uint256.
    /// All bits of the returned uint256 pass the NIST Statistical Test Suite.
    function next(PRNG memory prng) internal pure returns (uint256 result) {
        // We simply use `keccak256` for a great balance between
        // runtime gas costs, bytecode size, and statistical properties.
        //
        // A high-quality LCG with a 32-byte state
        // is only about 30% more gas efficient during runtime,
        // but requires a 32-byte multiplier, which can cause bytecode bloat
        // when this function is inlined.
        //
        // Using this method is about 2x more efficient than
        // `nextRandomness = uint256(keccak256(abi.encode(randomness)))`.
        /// @solidity memory-safe-assembly
        assembly {
            result := keccak256(prng, 0x20)
            mstore(prng, result)
        }
    }

    /// @dev Returns a pseudorandom uint256, uniformly distributed
    /// between 0 (inclusive) and `upper` (exclusive).
    /// If your modulus is big, this method is recommended
    /// for uniform sampling to avoid modulo bias.
    /// For uniform sampling across all uint256 values,
    /// or for small enough moduli such that the bias is neligible,
    /// use {next} instead.
    function uniform(
        PRNG memory prng,
        uint256 upper
    ) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {

            } 1 {

            } {
                result := keccak256(prng, 0x20)
                mstore(prng, result)
                if iszero(lt(result, mod(sub(0, upper), upper))) {
                    break
                }
            }
            result := mod(result, upper)
        }
    }

    /// @dev Shuffles the array in-place with Fisher-Yates shuffle.
    function shuffle(PRNG memory prng, uint256[] memory a) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(a)
            let w := not(0)
            let mask := shr(128, w)
            if n {
                for {
                    a := add(a, 0x20)
                } 1 {

                } {
                    // We can just directly use `keccak256`, cuz
                    // the other approaches don't save much.
                    let r := keccak256(prng, 0x20)
                    mstore(prng, r)

                    // Note that there will be a very tiny modulo bias
                    // if the length of the array is not a power of 2.
                    // For all practical purposes, it is negligible
                    // and will not be a fairness or security concern.
                    {
                        let j := add(a, shl(5, mod(shr(128, r), n)))
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let i := add(a, shl(5, n))
                        let t := mload(i)
                        mstore(i, mload(j))
                        mstore(j, t)
                    }

                    {
                        let j := add(a, shl(5, mod(and(r, mask), n)))
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let i := add(a, shl(5, n))
                        let t := mload(i)
                        mstore(i, mload(j))
                        mstore(j, t)
                    }
                }
            }
        }
    }

    /// @dev Shuffles the bytes in-place with Fisher-Yates shuffle.
    function shuffle(PRNG memory prng, bytes memory a) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(a)
            let w := not(0)
            let mask := shr(128, w)
            if n {
                let b := add(a, 0x01)
                for {
                    a := add(a, 0x20)
                } 1 {

                } {
                    // We can just directly use `keccak256`, cuz
                    // the other approaches don't save much.
                    let r := keccak256(prng, 0x20)
                    mstore(prng, r)

                    // Note that there will be a very tiny modulo bias
                    // if the length of the array is not a power of 2.
                    // For all practical purposes, it is negligible
                    // and will not be a fairness or security concern.
                    {
                        let o := mod(shr(128, r), n)
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let t := mload(add(b, n))
                        mstore8(add(a, n), mload(add(b, o)))
                        mstore8(add(a, o), t)
                    }

                    {
                        let o := mod(and(r, mask), n)
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) {
                            break
                        }

                        let t := mload(add(b, n))
                        mstore8(add(a, n), mload(add(b, o)))
                        mstore8(add(a, o), t)
                    }
                }
            }
        }
    }

    /// @dev Returns a sample from the standard normal distribution denominated in `WAD`.
    function standardNormalWad(
        PRNG memory prng
    ) internal pure returns (int256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Technically, this is the Irwin-Hall distribution with 20 samples.
            // The chance of drawing a sample outside 10 σ from the standard normal distribution
            // is ≈ 0.000000000000000000000015, which is insignificant for most practical purposes.
            // Passes the Kolmogorov-Smirnov test for 200k samples. Uses about 322 gas.
            result := keccak256(prng, 0x20)
            mstore(prng, result)
            let
                n
            := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff43 // Prime.
            let a := 0x100000000000000000000000000000051 // Prime and a primitive root of `n`.
            let
                m
            := 0x1fffffffffffffff1fffffffffffffff1fffffffffffffff1fffffffffffffff
            let s := 0x1000000000000000100000000000000010000000000000001
            let r1 := mulmod(result, a, n)
            let r2 := mulmod(r1, a, n)
            let r3 := mulmod(r2, a, n)
            // forgefmt: disable-next-item
            result := sub(
                sar(
                    96,
                    mul(
                        26614938895861601847173011183,
                        add(
                            add(
                                shr(
                                    192,
                                    mul(s, add(and(m, result), and(m, r1)))
                                ),
                                shr(192, mul(s, add(and(m, r2), and(m, r3))))
                            ),
                            shr(192, mul(s, and(m, mulmod(r3, a, n))))
                        )
                    )
                ),
                7745966692414833770
            )
        }
    }

    /// @dev Returns a sample from the unit exponential distribution denominated in `WAD`.
    function exponentialWad(
        PRNG memory prng
    ) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Passes the Kolmogorov-Smirnov test for 200k samples.
            // Gas usage varies, starting from about 172+ gas.
            let r := keccak256(prng, 0x20)
            mstore(prng, r)
            let p := shl(129, r)
            let w := shl(1, r)
            if iszero(gt(w, p)) {
                let
                    n
                := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff43 // Prime.
                let a := 0x100000000000000000000000000000051 // Prime and a primitive root of `n`.
                for {

                } 1 {

                } {
                    r := mulmod(r, a, n)
                    if iszero(lt(shl(129, r), w)) {
                        r := mulmod(r, a, n)
                        result := add(1000000000000000000, result)
                        w := shl(1, r)
                        p := shl(129, r)
                        if iszero(lt(w, p)) {
                            break
                        }
                        continue
                    }
                    w := shl(1, r)
                    if iszero(lt(w, shl(129, r))) {
                        break
                    }
                }
            }
            result := add(div(p, shl(129, 170141183460469231732)), result)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*       STORAGE-BASED RANGE LAZY SHUFFLING OPERATIONS        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Initializes the state for lazy-shuffling the range `[0..n)`.
    /// Reverts if `n == 0 || n >= 2**32 - 1`.
    /// Reverts if `$` has already been initialized.
    /// If you need to reduce the length after initialization, just use a fresh new `$`.
    function initialize(LazyShuffler storage $, uint256 n) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(lt(sub(n, 1), 0xfffffffe)) {
                mstore(0x00, 0x83b53941) // `InvalidInitialLazyShufflerLength()`.
                revert(0x1c, 0x04)
            }
            if sload($.slot) {
                mstore(0x00, 0x0c9f11f2) // `LazyShufflerAlreadyInitialized()`.
                revert(0x1c, 0x04)
            }
            mstore(0x00, $.slot)
            sstore(
                $.slot,
                or(shl(224, n), shl(32, shr(64, keccak256(0x00, 0x20))))
            )
        }
    }

    /// @dev Increases the length of `$`.
    /// Reverts if `$` has not been initialized.
    function grow(LazyShuffler storage $, uint256 n) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot) // The packed value at `$`.
            // If the new length is smaller than the old length, revert.
            if lt(n, shr(224, state)) {
                mstore(0x00, 0xbed37c6e) // `InvalidNewLazyShufflerLength()`.
                revert(0x1c, 0x04)
            }
            if iszero(state) {
                mstore(0x00, 0x1ead2566) // `LazyShufflerNotInitialized()`.
                revert(0x1c, 0x04)
            }
            sstore($.slot, or(shl(224, n), shr(32, shl(32, state))))
        }
    }

    /// @dev Restarts the shuffler by setting `numShuffled` to zero,
    /// such that all elements can be drawn again.
    /// Restarting does NOT clear the internal permutation, nor changes the length.
    /// Even with the same sequence of randomness, reshuffling can yield different results.
    function restart(LazyShuffler storage $) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot)
            if iszero(state) {
                mstore(0x00, 0x1ead2566) // `LazyShufflerNotInitialized()`.
                revert(0x1c, 0x04)
            }
            sstore($.slot, shl(32, shr(32, state)))
        }
    }

    /// @dev Returns the number of elements that have been shuffled.
    function numShuffled(
        LazyShuffler storage $
    ) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := and(0xffffffff, sload($.slot))
        }
    }

    /// @dev Returns the length of `$`.
    /// Returns zero if `$` is not initialized, else a non-zero value less than `2**32 - 1`.
    function length(
        LazyShuffler storage $
    ) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := shr(224, sload($.slot))
        }
    }

    /// @dev Returns if `$` has been initialized.
    function initialized(
        LazyShuffler storage $
    ) internal view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := iszero(iszero(sload($.slot)))
        }
    }

    /// @dev Returns if there are any more elements left to shuffle.
    /// Reverts if `$` is not initialized.
    function finished(
        LazyShuffler storage $
    ) internal view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot) // The packed value at `$`.
            if iszero(state) {
                mstore(0x00, 0x1ead2566) // `LazyShufflerNotInitialized()`.
                revert(0x1c, 0x04)
            }
            result := eq(shr(224, state), and(0xffffffff, state))
        }
    }

    /// @dev Returns the current value stored at `index`, accounting for all historical shuffling.
    /// Reverts if `index` is greater than or equal to the `length` of `$`.
    function get(
        LazyShuffler storage $,
        uint256 index
    ) internal view returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let state := sload($.slot) // The packed value at `$`.
            let n := shr(224, state) // Length of `$`.
            if iszero(lt(index, n)) {
                mstore(0x00, 0x61367cc4) // `LazyShufflerGetOutOfBounds()`.
                revert(0x1c, 0x04)
            }
            let u32 := gt(n, 0xfffe)
            let s := add(shr(sub(4, u32), index), shr(64, shl(32, state))) // Bucket slot.
            let o := shl(add(4, u32), and(index, shr(u32, 15))) // Bucket slot offset (bits).
            let m := sub(shl(shl(u32, 16), 1), 1) // Value mask.
            result := and(m, shr(o, sload(s)))
            result := xor(
                index,
                mul(xor(index, sub(result, 1)), iszero(iszero(result)))
            )
        }
    }

    /// @dev Does a single Fisher-Yates shuffle step, increments the `numShuffled` in `$`,
    /// and returns the next value in the shuffled range.
    /// `randomness` can be taken from a good-enough source, or a higher quality source like VRF.
    /// Reverts if there are no more values to shuffle, which includes the case if `$` is not initialized.
    function next(
        LazyShuffler storage $,
        uint256 randomness
    ) internal returns (uint256 chosen) {
        /// @solidity memory-safe-assembly
        assembly {
            function _get(u32_, state_, i_) -> _value {
                let s_ := add(shr(sub(4, u32_), i_), shr(64, shl(32, state_))) // Bucket slot.
                let o_ := shl(add(4, u32_), and(i_, shr(u32_, 15))) // Bucket slot offset (bits).
                let m_ := sub(shl(shl(u32_, 16), 1), 1) // Value mask.
                _value := and(m_, shr(o_, sload(s_)))
                _value := xor(
                    i_,
                    mul(xor(i_, sub(_value, 1)), iszero(iszero(_value)))
                )
            }
            function _set(u32_, state_, i_, value_) {
                let s_ := add(shr(sub(4, u32_), i_), shr(64, shl(32, state_))) // Bucket slot.
                let o_ := shl(add(4, u32_), and(i_, shr(u32_, 15))) // Bucket slot offset (bits).
                let m_ := sub(shl(shl(u32_, 16), 1), 1) // Value mask.
                let v_ := sload(s_) // Bucket slot value.
                value_ := mul(iszero(eq(i_, value_)), add(value_, 1))
                sstore(s_, xor(v_, shl(o_, and(m_, xor(shr(o_, v_), value_)))))
            }
            let state := sload($.slot) // The packed value at `$`.
            let shuffled := and(0xffffffff, state) // Number of elements shuffled.
            let n := shr(224, state) // Length of `$`.
            let remainder := sub(n, shuffled) // Number of elements left to shuffle.
            if iszero(remainder) {
                mstore(0x00, 0x51065f79) // `LazyShuffleFinished()`.
                revert(0x1c, 0x04)
            }
            mstore(0x00, randomness) // (Re)hash the randomness so that we don't
            mstore(0x20, shuffled) // need to expect guarantees on its distribution.
            let index := add(mod(keccak256(0x00, 0x40), remainder), shuffled)
            chosen := _get(gt(n, 0xfffe), state, index)
            _set(
                gt(n, 0xfffe),
                state,
                index,
                _get(gt(n, 0xfffe), state, shuffled)
            )
            _set(gt(n, 0xfffe), state, shuffled, chosen)
            sstore($.slot, add(1, state)) // Increment the `numShuffled` by 1, and store it.
        }
    }
}

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/utils/Strings.sol";



contract LiberoERC1155_01 is ERC1155, ERC1155Burnable, Ownable, ERC1155Supply {
    string public name;
    string public symbol;
    address[] private _managers;
    mapping(uint256 tokenId => string) private _tokenUri;
    uint256 private _maxTokenId;

    constructor(
        uint256 startTokenId,
        uint256 endTokenId,
        string memory _uri,
        string memory _name,
        string memory _symbol,
        address initialOwner,
        address[] memory initialManagers
    ) ERC1155("") Ownable(initialOwner) {
        name = _name;
        symbol = _symbol;
        bool addSenderAsManager = true;
        for (uint256 i = 0; i < initialManagers.length; i++) {
            address initialManager = initialManagers[i];
            if (msg.sender == initialManager && msg.sender != address(0))
                addSenderAsManager = false;
            if (initialManager != address(0) && !_isManager(initialManager)) {
                _managers.push(initialManager);
            }
        }
        if (addSenderAsManager) {
            _managers.push(msg.sender);
        }
        newEdition(startTokenId, endTokenId, _uri);
        if (addSenderAsManager) {
            _managers.pop();
        }
    }

    function newEdition(
        uint256 startTokenId,
        uint256 endTokenId,
        string memory newUri
    ) public onlyOwnerOrManager {
        require(startTokenId > _maxTokenId, "INVALID_RANGE");
        require(startTokenId <= endTokenId, "INVALID_RANGE");

        for (uint256 tokenId = startTokenId; tokenId <= endTokenId; tokenId++) {
            require(bytes(_tokenUri[tokenId]).length == 0, "URI_ALREADY_SET");
            _tokenUri[tokenId] = string(
                abi.encodePacked(newUri, Strings.toString(tokenId), ".json")
            );
        }
        _maxTokenId = endTokenId;
    }

    function maxTokenId() public view onlyOwnerOrManager returns (uint256) {
        return _maxTokenId;
    }

    function setManagers(
        address[] memory newManagers,
        bool active
    ) public onlyOwnerOrManager {
        for (uint256 mi = 0; mi < newManagers.length; mi++) {
            address newManager = newManagers[mi];

            bool ok = _isManager(newManager);
            if (ok == active) continue;
            if (active) {
                if (newManager != address(0)) {
                    _managers.push(newManager);
                }
            } else {
                for (uint256 i = 0; i < _managers.length; i++) {
                    if (_managers[i] == newManager) {
                        _managers[i] = _managers[_managers.length - 1];
                        _managers.pop();
                        break;
                    }
                }
            }
        }
    }

    function clearManagers() public {
        require(msg.sender == owner(), "ONLY_OWNER");
        delete _managers;
    }

    function getManagers() public view returns (address[] memory) {
        return _managers;
    }

    function _isManager(address manager) internal view returns (bool) {
        for (uint256 i = 0; i < _managers.length; i++) {
            if (manager == _managers[i]) {
                return true;
            }
        }
        return false;
    }

    modifier onlyOwnerOrManager() {
        require(
            msg.sender == owner() || _isManager(msg.sender),
            "ONLY_OWNER_OR_MANAGER"
        );
        _;
    }

    function uri(
        uint256 tokenId
    ) public view virtual override(ERC1155) returns (string memory) {
        return _tokenUri[tokenId];
    }

    function mint(
        address account,
        uint256 tokenId,
        uint256 amount,
        bytes memory data
    ) public onlyOwnerOrManager {
        _mint(account, tokenId, amount, data);
    }

    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public onlyOwnerOrManager {
        _mintBatch(to, ids, amounts, data);
    }

    // The following functions are overrides required by Solidity.

    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal override(ERC1155, ERC1155Supply) {
        super._update(from, to, ids, values);
    }
}

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";



contract LiberoERC721_01 is ERC721, ERC721Enumerable, ERC721Burnable, Ownable {
    struct Edition {
        uint256 startTokenId;
        uint256 endTokenId;
        string baseUrl;
    }
    Edition[] private _editions;

    address[] private _managers;
    mapping(uint256 => string) public tokenToUri;

    constructor(
        uint256 startTokenId,
        uint256 endTokenId,
        string memory uri,
        string memory name,
        string memory symbol,
        address initialOwner,
        address[] memory initialManagers
    ) ERC721(name, symbol) Ownable(initialOwner) {
        // make sender manager to be able to create new edition and mint
        bool addSenderAsManager = true;
        for (uint256 i = 0; i < initialManagers.length; i++) {
            address initialManager = initialManagers[i];
            if (msg.sender == initialManager && msg.sender != address(0))
                addSenderAsManager = false;
            if (initialManager != address(0) && !_isManager(initialManager)) {
                _managers.push(initialManager);
            }
        }
        if (addSenderAsManager) {
            _managers.push(msg.sender);
        }
        newEdition(startTokenId, endTokenId, uri);
        if (addSenderAsManager) {
            _managers.pop();
        }
    }

    function newEdition(
        uint256 startTokenId,
        uint256 endTokenId,
        string memory baseUrl
    ) public onlyOwnerOrManager {
        require(startTokenId <= endTokenId, "INVALID_RANGE");

        // Check for overlapping editions
        for (uint256 i = 0; i < _editions.length; i++) {
            Edition memory existingRange = _editions[i];
            require(
                endTokenId < existingRange.startTokenId ||
                    startTokenId > existingRange.endTokenId,
                "RANGE_NO_OVERLAP"
            );
        }
        // Add the new range
        _editions.push(Edition(startTokenId, endTokenId, baseUrl));
        // Sort the editions by startTokenId using insertion sort
        if (_editions.length > 1) {
            uint256 j = _editions.length - 1;
            Edition memory ne = _editions[j];

            while (j > 0 && _editions[j - 1].startTokenId > ne.startTokenId) {
                _editions[j] = _editions[j - 1];
                j--;
            }

            if (j != _editions.length - 1) {
                _editions[j] = ne;
            }
        }
    }

    function listEditions()
        public
        view
        onlyOwnerOrManager
        returns (Edition[] memory)
    {
        return _editions;
    }

    function maxTokenId() public view onlyOwnerOrManager returns (uint256) {
        require(_editions.length > 0, "NO_EDITIONS");
        return _editions[_editions.length - 1].endTokenId;
    }

    function getEditionBaseUrl(
        uint256 tokenId
    ) public view onlyOwnerOrManager returns (string memory) {
        return _getEditionBaseUrl(tokenId);
    }

    function _getEditionBaseUrl(
        uint256 tokenId
    ) internal view returns (string memory) {
        // Perform binary search to find the range that contains the tokenId
        uint256 low = 0;
        uint256 high = _editions.length - 1;

        while (low <= high) {
            uint256 mid = (low + high) / 2;
            Edition memory edition = _editions[mid];

            if (
                edition.startTokenId <= tokenId && tokenId <= edition.endTokenId
            ) {
                return edition.baseUrl;
            } else if (tokenId < edition.startTokenId) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        revert("NO_BASE_URL");
    }

    function setManagers(
        address[] memory newManagers,
        bool active
    ) public onlyOwnerOrManager {
        for (uint256 mi = 0; mi < newManagers.length; mi++) {
            address newManager = newManagers[mi];

            bool ok = _isManager(newManager);
            if (ok == active) continue;
            if (active) {
                if (newManager != address(0)) {
                    _managers.push(newManager);
                }
            } else {
                for (uint256 i = 0; i < _managers.length; i++) {
                    if (_managers[i] == newManager) {
                        _managers[i] = _managers[_managers.length - 1];
                        _managers.pop();
                        break;
                    }
                }
            }
        }
    }

    function clearManagers() public {
        require(msg.sender == owner(), "ONLY_OWNER");
        delete _managers;
    }

    function getManagers() public view returns (address[] memory) {
        return _managers;
    }

    function _isManager(address manager) internal view returns (bool) {
        for (uint256 i = 0; i < _managers.length; i++) {
            if (manager == _managers[i]) {
                return true;
            }
        }
        return false;
    }

    modifier onlyOwnerOrManager() {
        require(
            msg.sender == owner() || _isManager(msg.sender),
            "ONLY_OWNER_OR_MANAGER"
        );
        _;
    }

    function tokenURI(
        uint256 tokenId
    ) public view virtual override(ERC721) returns (string memory) {
        return tokenToUri[tokenId];
    }

    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal override(ERC721, ERC721Enumerable) returns (address) {
        return super._update(to, tokenId, auth);
    }

    function _increaseBalance(
        address account,
        uint128 value
    ) internal override(ERC721, ERC721Enumerable) {
        super._increaseBalance(account, value);
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view override(ERC721, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function mintTo(
        address to,
        uint256 tokenId
    ) public virtual onlyOwnerOrManager {
        string memory _uri = _getEditionBaseUrl(tokenId);
        tokenToUri[tokenId] = string(
            abi.encodePacked(_uri, Strings.toString(tokenId), ".json")
        );
        _safeMint(to, tokenId);
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.24;

import "./LiberoERC1155_01.sol";

contract LiberoMintFactory1155_01 {
    event ERC1155Deployed(address contractAddress);

    function deployLiberoERC1155(
        uint256 startTokenId,
        uint256 endTokenId,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        address initialOwner,
        address initialManager
    ) public returns (LiberoERC1155_01 contractAddress) {
        address[] memory initialManagers = new address[](2);
        initialManagers[0] = initialManager;
        initialManagers[1] = msg.sender; // campaign contract
        LiberoERC1155_01 erc1155 = new LiberoERC1155_01(
            startTokenId,
            endTokenId,
            mintUri,
            mintName,
            mintSymbol,
            initialOwner,
            initialManagers
        );
        emit ERC1155Deployed(address(erc1155));
        return erc1155;
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.24;

import "./LiberoWL_01.sol";
import "./LiberoERC721_01.sol";

contract LiberoMintFactory721_01 {
    event ERC721Deployed(address contractAddress);
    event ERC721WLDeployed(address contractAddress);

    function deployLiberoWL(
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        address initialOwner,
        address initialManager
    ) public returns (LiberoWL_01 contractAddress) {
        address[] memory initialManagers = new address[](2);
        initialManagers[0] = initialManager;
        initialManagers[1] = msg.sender; // campaign contract
        LiberoWL_01 wl = new LiberoWL_01(
            mintUri,
            mintName,
            mintSymbol,
            initialOwner,
            initialManagers
        );
        emit ERC721WLDeployed(address(wl));
        return wl;
    }

    function deployLiberoERC721(
        uint256 startTokenId,
        uint256 endTokenId,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        address initialOwner,
        address initialManager
    ) public returns (LiberoERC721_01 contractAddress) {
        address[] memory initialManagers = new address[](2);
        initialManagers[0] = initialManager;
        initialManagers[1] = msg.sender; // campaign contract
        LiberoERC721_01 erc721 = new LiberoERC721_01(
            startTokenId,
            endTokenId,
            mintUri,
            mintName,
            mintSymbol,
            initialOwner,
            initialManagers
        );
        emit ERC721Deployed(address(erc721));
        return erc721;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./LiberoERC721_01.sol";
import "./LiberoERC1155_01.sol";
import "./LiberoMintFactory721_01.sol";
import "./LiberoMintFactory1155_01.sol";
import "./LiberoReward_01.sol";
import "./LibPRNG_01.sol";
import "./Ticketing_01.sol";
import "./TicketingFactory_01.sol";



contract SoladyPRNG {
    LibPRNG_01.PRNG private state;

    constructor(uint256 _state) {
        state = LibPRNG_01.PRNG(_state);
    }

    // Generates a pseudo-random number between 0 and _upperBound (exclusive)
    function random(uint256 _upperBound) public view returns (uint256) {
        return LibPRNG_01.uniform(state, _upperBound);
    }
}

contract LiberoRaffle_01 is Ownable {
    LiberoRewards_01.Raffle[] private _raffleInfo;
    LiberoRewards_01.RaffleExt[] private _raffleExt;
    uint32 private _raffleNr;
    address private _manager;
    LiberoMintFactory721_01 private _liberoMintFactory721;
    LiberoMintFactory1155_01 private _liberoMintFactory1155;
    TicketingFactory_01 private _ticketingFactory;

    constructor(
        address manager,
        address liberoMintFactory721,
        address liberoMintFactory1155,
        address ticketingFactory
    ) Ownable(msg.sender) {
        _liberoMintFactory721 = LiberoMintFactory721_01(liberoMintFactory721);
        _liberoMintFactory1155 = LiberoMintFactory1155_01(
            liberoMintFactory1155
        );
        _ticketingFactory = TicketingFactory_01(ticketingFactory);
        _manager = manager;
    }

    modifier onlyManager() {
        require(_manager == msg.sender, "CALLER_NOT_MANAGER");
        _;
    }

    function setManager(address manager) public onlyOwner {
        _manager = manager;
    }

    function newRaffle(
        uint32 id,
        uint256 payAmount,
        address organizer,
        uint32 totalTickets,
        uint32 totalPriorityTickets,
        uint32 maxTicketsPerWallet,
        uint32 maxRewardsPerWallet,
        uint32 availableRewards,
        uint32 startTokenId,
        uint32 endTokenId,
        uint8 rewardIf,
        address rewardContract,
        address existingMintContract,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        bool isWhitelistMint,
        bool shouldDistributeRewards,
        bool shouldRefundNonWinning,
        uint256 startAt,
        uint256 endAt,
        uint256 raffleAt,
        uint256 sysTicketPrice,
        uint16 ownerSysFeePct,
        uint16 ownerFeePct,
        uint16 ownerTipPct,
        LiberoRewards_01.Requirement[] memory requirements,
        bytes memory signature
    ) public payable {
        address recoveredSigner = LiberoRewards_01
            .ext_newRaffleValidateAndCheckSignature(
                id,
                payAmount,
                organizer,
                totalTickets,
                totalPriorityTickets,
                maxTicketsPerWallet,
                maxRewardsPerWallet,
                availableRewards,
                startTokenId,
                endTokenId,
                rewardIf,
                rewardContract,
                existingMintContract,
                mintUri,
                mintName,
                mintSymbol,
                isWhitelistMint,
                shouldDistributeRewards,
                shouldRefundNonWinning,
                startAt,
                endAt,
                raffleAt,
                sysTicketPrice,
                ownerSysFeePct,
                ownerFeePct,
                ownerTipPct,
                requirements,
                signature
            );
        require(recoveredSigner == _manager, "RAFFLE_NEEDS_VALID_SIGNATURE");

        _raffleInfo.push();
        _raffleExt.push();
        _raffleNr = uint16(_raffleInfo.length) - 1;

        LiberoRewards_01.Raffle storage _newRaffle = _raffleInfo[_raffleNr];

        _newRaffle.availableRewards = availableRewards;
        _newRaffle.rewardIf = rewardIf;
        _newRaffle.organizer = organizer;
        _newRaffle.rewardContract = rewardContract;
        _newRaffle.availableRewards = availableRewards;
        _newRaffle.shouldDistributeRewards = shouldDistributeRewards;
        _newRaffle.shouldRefundNonWinning = shouldRefundNonWinning;
        _newRaffle.startAt = startAt;
        _newRaffle.endAt = endAt;
        _newRaffle.raffleAt = raffleAt;
        _newRaffle.sysTicketPrice = sysTicketPrice;
        _newRaffle.ownerSysFeePct = ownerSysFeePct;
        _newRaffle.ownerFeePct = ownerFeePct;
        _newRaffle.ownerTipPct = ownerTipPct;

        _newRaffle.requirements = requirements;
        _newRaffle.tickets = _ticketingFactory.deployTicketing(
            address(this),
            totalTickets,
            totalPriorityTickets,
            maxTicketsPerWallet
        );
        _newRaffle.maxRewardsPerWallet = maxRewardsPerWallet;

        _newRaffle.mintContract = LiberoRewards_01.ext_newRaffleDeploy(
            _manager,
            organizer,
            rewardIf,
            rewardContract,
            existingMintContract,
            startTokenId,
            endTokenId,
            mintUri,
            mintName,
            mintSymbol,
            isWhitelistMint,
            shouldDistributeRewards,
            _liberoMintFactory721,
            _liberoMintFactory1155
        );

        payable(owner()).transfer(payAmount);

        emit LiberoRewards_01.RaffleCreated(_raffleNr, id);
    }

    function addRewards(
        uint32 raffleNr,
        uint256 from,
        LiberoRewards_01.Reward[] memory rewards
    ) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        require(activeRaffle.rewards.length == from, "ADD_REWARDS_FROM_ERROR");
        require(
            rewards.length + activeRaffle.rewards.length <=
                activeRaffle.availableRewards,
            "ADD_REWARDS_TOO_MANY"
        );

        if (
            activeRaffle.shouldDistributeRewards &&
            activeRaffle.rewardContract != address(0)
        ) {
            LiberoRewards_01.ext_approveAwardInternal(
                activeRaffle.rewardIf,
                activeRaffle.rewardContract,
                activeRaffle.organizer,
                rewards
            );
        }

        for (uint256 i = 0; i < rewards.length; i++) {
            activeRaffle.rewards.push(rewards[i]);
        }

        activeRaffle.totalRewards = activeRaffle.rewards.length;
    }

    function getRaffleInfo(
        uint32 raffleNr
    ) public view onlyManager returns (LiberoRewards_01.Raffle memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        delete activeRaffle.rewards;
        delete activeRaffle.tickets;
        delete activeRaffle.winningTickets;

        return activeRaffle;
    }

    function getRaffleInfoCnt(
        uint32 raffleNr
    )
        public
        view
        onlyManager
        returns (
            uint256 rewardsLen,
            uint256 ticketsLen,
            uint256 ticketsValidPriorityLen,
            uint256 ticketsValidLen,
            uint256 winningTicketsLen,
            bool validated
        )
    {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        rewardsLen = activeRaffle.rewards.length;
        ticketsLen = activeRaffle.tickets.getAllTicketsLength();
        ticketsValidPriorityLen = activeRaffle.tickets.getValidTicketsLength(
            true
        );
        ticketsValidLen = activeRaffle.tickets.getValidTicketsLength(false);
        winningTicketsLen = activeRaffle.winningTickets.length;
        validated = activeRaffle.tickets.getTicketsValidated();
    }

    function getRaffleInfoRewards(
        uint32 raffleNr,
        uint256 fromIx,
        uint256 toIx
    ) public view onlyManager returns (LiberoRewards_01.Reward[] memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        LiberoRewards_01.Reward[] memory res = new LiberoRewards_01.Reward[](
            toIx - fromIx
        );
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.rewards[i];
        }

        return res;
    }

    function getRaffleInfoTickets(
        uint32 raffleNr,
        uint256 fromIx,
        uint256 toIx
    ) public view onlyManager returns (Ticketing_01.Ticket[] memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        Ticketing_01.Ticket[] memory res = new Ticketing_01.Ticket[](
            toIx - fromIx
        );
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.tickets.getTicketAt(i);
        }

        return res;
    }

    function getRaffleInfoValidTickets(
        uint32 raffleNr,
        bool isPriority,
        uint256 fromIx,
        uint256 toIx
    ) public view onlyManager returns (Ticketing_01.Ticket[] memory) {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        Ticketing_01.Ticket[] memory res = new Ticketing_01.Ticket[](
            toIx - fromIx
        );
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.tickets.getValidTicketAtIx(
                isPriority,
                i
            );
        }

        return res;
    }

    function getRaffleInfoWinningTickets(
        uint32 raffleNr,
        uint256 fromIx,
        uint256 toIx
    )
        public
        view
        onlyManager
        returns (LiberoRewards_01.WinningTicket[] memory)
    {
        LiberoRewards_01.Raffle memory activeRaffle = _raffleInfo[raffleNr];

        LiberoRewards_01.WinningTicket[]
            memory res = new LiberoRewards_01.WinningTicket[](toIx - fromIx);
        for (uint256 i = fromIx; i < toIx; i++) {
            res[i - fromIx] = activeRaffle.winningTickets[i];
        }

        return res;
    }

    function getRaffleInfoRewardsPerWallet(
        uint32 raffleNr,
        address wallet
    ) public view onlyManager returns (uint32) {
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];
        return activeRaffleExt.rewardsPerWallet[wallet];
    }

    function getRaffleInfoWinningTicketKeys(
        uint32 raffleNr,
        Ticketing_01.Ticket memory ticket
    ) public view onlyManager returns (bool) {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];
        uint256 ticketKey = activeRaffle.tickets.getTicketKeyExt(ticket);
        return activeRaffleExt.winningTicketKeys[ticketKey];
    }

    function getRaffleInfoTicketKeyExt(
        uint32 raffleNr,
        Ticketing_01.Ticket memory ticket
    ) public view onlyManager returns (uint256) {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        return activeRaffle.tickets.getTicketKeyExt(ticket);
    }

    function getRaffleInfoTicketValidationInfo(
        uint32 raffleNr
    )
        public
        view
        returns (
            uint256 _validatedUntil,
            bool _validated,
            uint256 _totalTickets,
            uint256 _totalPriorityTickets,
            uint256 _maxTicketsPerWallet,
            uint256 _totalTicketsSold,
            uint256 _returnedTickets
        )
    {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        return activeRaffle.tickets.getTicketValidationInfo();
    }

    function buyTickets(
        uint32 raffleNr,
        Ticketing_01.Ticket[] calldata toBuy,
        Ticketing_01.Ticket[] calldata toReturn,
        uint256 tip,
        bytes memory signature
    ) public payable {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        (
            address recoveredSigner,
            uint256 netPayAmount,
            uint256 netRefundAmount
        ) = LiberoRewards_01.ext_buyTicketsValidateAndCheckSignature(
                raffleNr,
                activeRaffle,
                toBuy,
                toReturn,
                tip,
                signature
            );

        require(
            recoveredSigner == _manager,
            "BUY_TICKET_NEEDS_VALID_SIGNATURE"
        );
        require(!activeRaffle.prngInitialized, "PRNG_ALREADY_INITIALIZED");

        if (toBuy.length > 0) activeRaffle.tickets.buyTickets(raffleNr, toBuy);
        if (toReturn.length > 0)
            activeRaffle.tickets.returnTickets(raffleNr, toReturn);

        uint256 sysFee = toBuy.length * activeRaffle.sysTicketPrice;
        uint256 ownerSysFee = (sysFee * activeRaffle.ownerSysFeePct) / 100;
        uint256 organizerSysFee = sysFee - ownerSysFee;

        if (organizerSysFee > 0) {
            payable(activeRaffle.organizer).transfer(organizerSysFee);
        }
        if (ownerSysFee > 0) {
            payable(owner()).transfer(ownerSysFee);
        }
        if (netPayAmount > 0) {
            activeRaffle.fees += netPayAmount;
        } else {
            activeRaffle.fees -= netRefundAmount;
            payable(msg.sender).transfer(netRefundAmount);
        }
        activeRaffle.tips += tip;

        emit LiberoRewards_01.Payment(
            raffleNr,
            msg.sender,
            uint128(sysFee),
            uint128(ownerSysFee),
            uint128(tip),
            uint128(netPayAmount),
            netRefundAmount > 0
        );
    }

    function seedRaffle(uint32 raffleNr, uint256 seed) public {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        require(
            activeRaffle.availableRewards == activeRaffle.rewards.length,
            "REWARDS_NOT_ADDED"
        );

        require(
            (msg.sender == activeRaffle.organizer) ||
                (msg.sender == _manager &&
                    block.timestamp >= activeRaffle.raffleAt),
            "SEED_RAFFLE_NOT_AUTHORIZED"
        );

        require(!activeRaffle.prngInitialized, "PRNG_ALREADY_INITIALIZED");

        activeRaffle.prngState = uint256(
            keccak256(
                abi.encodePacked(
                    block.prevrandao,
                    block.timestamp,
                    block.number,
                    msg.sender,
                    address(this),
                    raffleNr,
                    seed
                )
            )
        );
        activeRaffle.prngInitialized = true;
    }

    function validateTickets(uint32 raffleNr, uint256 cnt) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        activeRaffle.tickets.validateTickets(cnt);

        if (activeRaffle.tickets.getTicketsValidated()) {
            activeRaffle.totalTickets =
                activeRaffle.tickets.getValidTicketsLength(true) +
                activeRaffle.tickets.getValidTicketsLength(false);
            if (activeRaffle.totalRewards > activeRaffle.totalTickets) {
                activeRaffle.totalRewards = activeRaffle.totalTickets;
            }
        }
    }

    function raffle(
        uint32 raffleNr,
        bool isPriority,
        uint256 cnt
    ) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        require(
            activeRaffle.tickets.getTicketsValidated(),
            "TICKETS_NOT_VALIDATED"
        );
        uint256 priorityTicketsLength = activeRaffle
            .tickets
            .getValidTicketsLength(true);
        require(
            activeRaffle.nextRewardIx < activeRaffle.totalRewards,
            "RAFFLE_FINISHED"
        );
        if (isPriority) {
            require(
                activeRaffle.pickedRewards < priorityTicketsLength,
                "RAFFLE_FINISHED_PRIORITY"
            );
        } else {
            require(
                activeRaffle.pickedRewards >= priorityTicketsLength,
                "RAFFLE_NOT_FINISHED_PRIORITY"
            );
            require(
                activeRaffle.nextRewardIx < activeRaffle.totalTickets,
                "RAFFLE_FINISHED_OTHER"
            );
        }

        SoladyPRNG prng = new SoladyPRNG(activeRaffle.prngState);
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];

        // how many tickets to draw from, accounting for round and already drawn tickets
        uint256 drawTotalTickets = isPriority
            ? priorityTicketsLength
            : activeRaffle.totalTickets;
        drawTotalTickets -= activeRaffle.pickedRewards;
        require(drawTotalTickets > 0, "RAFFLE_FINISHED_NO_MORE_TICKETS");

        uint256 drawRounds = drawTotalTickets;
        // limit #draws to available tickets
        if (drawRounds > drawTotalTickets) drawRounds = drawTotalTickets;
        // limit #draws to external rate limit
        if (drawRounds > cnt) drawRounds = cnt;

        for (uint256 i = 0; i < drawRounds; i++) {
            // if all rewards picked continue
            if (activeRaffle.nextRewardIx >= activeRaffle.totalRewards) {
                break;
            }

            uint256 winnerIx = prng.random(drawTotalTickets);
            Ticketing_01.Ticket memory winningTicket = activeRaffle
                .tickets
                .getValidTicketAtIx(isPriority, winnerIx);

            // move ticket from end to drawn place (unless already last), next draw will be from one less ticket
            if (winnerIx != drawTotalTickets - 1) {
                activeRaffle.tickets.swapValidTickets(
                    isPriority,
                    winnerIx,
                    drawTotalTickets - 1
                );
            }

            LiberoRewards_01.Reward memory reward = activeRaffle.rewards[
                activeRaffle.nextRewardIx
            ];
            uint32 rewardsPerWallet = activeRaffleExt.rewardsPerWallet[
                winningTicket.wallet
            ] + 1;
            activeRaffleExt.rewardsPerWallet[
                winningTicket.wallet
            ] = rewardsPerWallet;
            bool isSkipped = false;
            if (rewardsPerWallet > activeRaffle.maxRewardsPerWallet) {
                isSkipped = true;
            } else {
                activeRaffle.nextRewardIx++;
            }

            activeRaffle.winningTickets.push(
                LiberoRewards_01.WinningTicket(winningTicket, reward, isSkipped)
            );
            if (!isSkipped) {
                uint256 ticketKey = activeRaffle.tickets.getTicketKeyExt(
                    winningTicket
                );
                activeRaffleExt.winningTicketKeys[ticketKey] = true;
            }

            emit LiberoRewards_01.TicketPicked(
                raffleNr,
                uint32(activeRaffle.winningTickets.length),
                uint32(winnerIx),
                uint32(drawTotalTickets),
                isSkipped,
                isPriority,
                reward.tokenId,
                reward.tokenAmount,
                winningTicket.tokenId,
                winningTicket.wallet,
                winningTicket.ticketId,
                winningTicket.ticketNr,
                winningTicket.reqNr
            );

            drawTotalTickets -= 1;
            activeRaffle.pickedRewards += 1;
        }
    }

    bool private _distributingRewards;

    function _burnRewardIxInternal(
        uint32 raffleNr,
        uint32 ix
    ) private returns (bool success) {
        require(!_distributingRewards);
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        if (activeRaffle.shouldDistributeRewards) {
            _distributingRewards = true;
            success = LiberoRewards_01.ext_burnRewardIxInternal(
                raffleNr,
                activeRaffle.winningTickets[ix],
                activeRaffle.requirements
            );
            _distributingRewards = false;
        }
    }

    function _sendRewardIxInternal(
        uint32 raffleNr,
        uint32 ix
    ) private returns (bool success) {
        require(!_distributingRewards);
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        if (activeRaffle.shouldDistributeRewards) {
            _distributingRewards = true;
            success = LiberoRewards_01.ext_sendRewardIxInternal(
                raffleNr,
                activeRaffle.winningTickets[ix],
                activeRaffle.rewardIf,
                activeRaffle.rewardContract,
                activeRaffle.mintContract,
                activeRaffle.organizer
            );
            _distributingRewards = false;
        }
    }

    function _distributeRewardIxInternal(uint32 raffleNr, uint32 ix) private {
        bool success = _burnRewardIxInternal(raffleNr, ix);

        // only transfer reward if no burn errors
        if (success) {
            success = _sendRewardIxInternal(raffleNr, ix);
        }
    }

    function distributeRewards(uint32 raffleNr, uint32 cnt) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        require(
            (activeRaffle.totalRewards == (activeRaffle.nextRewardIx)) ||
                (activeRaffle.pickedRewards == activeRaffle.totalTickets),
            "REWARDS_NOT_PICKED"
        );

        uint256 finalCnt = activeRaffle.distributeNextIx + cnt;
        if (finalCnt > activeRaffle.winningTickets.length) {
            finalCnt = activeRaffle.winningTickets.length;
        }
        require(
            finalCnt > activeRaffle.distributeNextIx,
            "REWARDS_DISTRIBUTED"
        );

        for (uint256 i = activeRaffle.distributeNextIx; i < finalCnt; i++) {
            _distributeRewardIxInternal(raffleNr, uint32(i));
            activeRaffle.distributeNextIx++;
        }
    }

    function distributeRewardIx(uint32 raffleNr, uint32 ix) public onlyManager {
        // Raffle storage activeRaffle = _raffleInfo[raffleNr];
        // if (activeRaffle.shouldDistributeRewards) {
        //     require(
        //         activeRaffle.distributeNextIx ==
        //             activeRaffle.winningTickets.length,
        //         "REWARDS_NOT_DISTRIBUTED"
        //     );
        // }
        _distributeRewardIxInternal(raffleNr, ix);
    }

    function burnRewardIx(uint32 raffleNr, uint32 ix) public onlyManager {
        // Raffle storage activeRaffle = _raffleInfo[raffleNr];
        // if (activeRaffle.shouldDistributeRewards) {
        //     require(
        //         activeRaffle.distributeNextIx ==
        //             activeRaffle.winningTickets.length,
        //         "REWARDS_NOT_DISTRIBUTED"
        //     );
        // }
        _burnRewardIxInternal(raffleNr, ix);
    }

    function burnRaw(
        address collection,
        address owner,
        uint8 rewardIf,
        uint256 tokenId,
        uint256 tokenAmount
    ) public onlyManager {
        if (rewardIf == IF_ERC721) {
            ERC721Burnable burn721 = ERC721Burnable(collection);
            burn721.burn(tokenId);
        } else if (rewardIf == IF_ERC1155) {
            ERC1155Burnable burn1155 = ERC1155Burnable(collection);
            burn1155.burn(owner, tokenId, tokenAmount);
        } else if (rewardIf == IF_MANIFOLD1155) {
            ManifoldERC1155Burnable burn1155 = ManifoldERC1155Burnable(
                collection
            );
            uint256[] memory ids = new uint256[](1);
            uint256[] memory values = new uint256[](1);
            ids[0] = tokenId;
            values[0] = tokenAmount;
            burn1155.burn(owner, ids, values);
        }
    }

    function transferRaw(
        address collection,
        address owner,
        address recepient,
        uint8 rewardIf,
        uint256 tokenId,
        uint256 tokenAmount
    ) public onlyManager {
        if (rewardIf == IF_ERC721) {
            IERC721 burn721 = IERC721(collection);
            burn721.safeTransferFrom(owner, recepient, tokenId);
        } else if (rewardIf == IF_ERC1155) {
            IERC1155 burn1155 = IERC1155(collection);
            burn1155.safeTransferFrom(
                owner,
                recepient,
                tokenId,
                tokenAmount,
                ""
            );
        }
    }

    function sendRewardIx(uint32 raffleNr, uint32 ix) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        if (activeRaffle.shouldDistributeRewards) {
            require(
                activeRaffle.distributeNextIx ==
                    activeRaffle.winningTickets.length,
                "REWARDS_NOT_DISTRIBUTED"
            );
        }
        _sendRewardIxInternal(raffleNr, ix);
    }

    bool private _refundingNonWinning;

    function refundNonWinning(
        uint32 raffleNr,
        bool isPriority,
        uint32 cnt
    ) public onlyManager {
        require(!_refundingNonWinning, "REFUND_NON_WINNING_LOCKED");
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        require(
            (activeRaffle.totalRewards == (activeRaffle.nextRewardIx)) ||
                (activeRaffle.pickedRewards == activeRaffle.totalTickets),
            "REWARDS_NOT_PICKED"
        );
        if (activeRaffle.shouldDistributeRewards) {
            require(
                activeRaffle.distributeNextIx ==
                    activeRaffle.winningTickets.length,
                "REWARDS_NOT_DISTRIBUTED"
            );
        }
        require(
            activeRaffle.shouldRefundNonWinning,
            "SHOULD_REFUND_NON_WINNING"
        );
        uint256 refundedIx = isPriority
            ? activeRaffle.refundedPriorityIx
            : activeRaffle.refundedIx;
        uint256 refundTicketsLen = activeRaffle.tickets.getValidTicketsLength(
            isPriority
        );
        require(refundedIx < refundTicketsLen, "REFUND_NON_WINNING_FINISHED");

        _refundingNonWinning = true;
        LiberoRewards_01.RaffleExt storage activeRaffleExt = _raffleExt[
            raffleNr
        ];

        uint256 upToIx = refundedIx + cnt;
        if (upToIx > refundTicketsLen) upToIx = refundTicketsLen;

        for (uint256 i = refundedIx; i < upToIx; i++) {
            Ticketing_01.Ticket memory ticket = activeRaffle
                .tickets
                .getValidTicketAtIx(isPriority, i);
            uint256 ticketKey = activeRaffle.tickets.getTicketKeyExt(ticket);
            if (!activeRaffleExt.winningTicketKeys[ticketKey]) {
                uint8 reqNr = ticket.reqNr;
                require(
                    reqNr < activeRaffle.requirements.length,
                    "TICKET_REFUND_NO_REQ_IX"
                );
                uint256 price = activeRaffle.requirements[reqNr].ticketPrice;
                if (price > 0) {
                    bool success = false;
                    try
                        LiberoRewards_01.ext_payAny(ticket.wallet, price, 10000)
                    returns (bool sent) {
                        success = sent;
                    } catch {}
                    if (success) {
                        activeRaffle.fees -= price;
                    }
                    emit LiberoRewards_01.TicketRefundNonWinning(
                        raffleNr,
                        ticket.tokenId,
                        ticket.wallet,
                        ticket.ticketId,
                        ticket.ticketNr,
                        ticket.reqNr,
                        success,
                        price
                    );
                }
            }
        }

        if (isPriority) {
            activeRaffle.refundedPriorityIx = upToIx;
        } else {
            activeRaffle.refundedIx = upToIx;
        }
        _refundingNonWinning = false;
    }

    function _checkRaffleDone(
        LiberoRewards_01.Raffle memory activeRaffle
    ) private view {
        require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        if (activeRaffle.shouldDistributeRewards) {
            require(
                activeRaffle.distributeNextIx ==
                    activeRaffle.winningTickets.length,
                "REWARDS_NOT_DISTRIBUTED"
            );
        }
        require(
            !activeRaffle.shouldRefundNonWinning ||
                (activeRaffle.refundedPriorityIx ==
                    activeRaffle.tickets.getValidTicketsLength(true) &&
                    activeRaffle.refundedIx ==
                    activeRaffle.tickets.getValidTicketsLength(false)),
            "SHOULD_REFUND_NON_WINNING"
        );
    }

    function payoutFees(uint32 raffleNr) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];
        _checkRaffleDone(activeRaffle);

        uint256 ownerFee = (activeRaffle.fees * activeRaffle.ownerFeePct) / 100;
        uint256 ownerTip = (activeRaffle.tips * activeRaffle.ownerTipPct) / 100;
        uint256 organizerFee = activeRaffle.fees +
            activeRaffle.tips -
            ownerFee -
            ownerTip;

        if (organizerFee > 0) {
            payable(activeRaffle.organizer).transfer(organizerFee);
        }
        if (ownerFee + ownerTip > 0) {
            payable(owner()).transfer(ownerFee + ownerTip);
        }

        activeRaffle.fees = 0;
        activeRaffle.tips = 0;
    }

    function transferMintOwnership(uint32 raffleNr) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        // require(activeRaffle.prngInitialized, "RAFFLE_PRNG_NOT_INITIALIZED");
        // if (activeRaffle.shouldDistributeRewards) {
        //     require(
        //         activeRaffle.fees == 0 && activeRaffle.tips == 0,
        //         "FEES_NOT_PAID_OUT"
        //     );
        // }

        if (activeRaffle.mintContract != address(0)) {
            if (activeRaffle.rewardIf == IF_ERC721) {
                LiberoERC721_01(activeRaffle.mintContract).transferOwnership(
                    activeRaffle.organizer
                );
            } else if (activeRaffle.rewardIf == IF_ERC1155) {
                LiberoERC1155_01(activeRaffle.mintContract).transferOwnership(
                    activeRaffle.organizer
                );
            }
        }
    }

    function batchMintManager(
        uint32 raffleNr,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts
    ) public onlyManager {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        LiberoRewards_01.ext_batchMint(
            activeRaffle.rewardIf,
            activeRaffle.mintContract,
            to,
            tokenIds,
            tokenAmounts
        );
    }

    function batchMintOwner(
        uint32 raffleNr,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts,
        bytes memory signature
    ) public {
        LiberoRewards_01.Raffle storage activeRaffle = _raffleInfo[raffleNr];

        _checkRaffleDone(activeRaffle);
        address recoveredSigner = LiberoRewards_01.ext_batchMintCheckSignature(
            raffleNr,
            to,
            tokenIds,
            tokenAmounts,
            signature
        );
        require(
            recoveredSigner == _manager,
            "BATCH_MINT_NEEDS_VALID_SIGNATURE"
        );

        LiberoRewards_01.ext_batchMint(
            activeRaffle.rewardIf,
            activeRaffle.mintContract,
            to,
            tokenIds,
            tokenAmounts
        );
    }

    function withdraw(uint256 amount) public onlyOwner {
        payable(owner()).transfer(amount);
    }

    function fund() public payable {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "./LiberoWL_01.sol";
import "./LiberoERC721_01.sol";
import "./LiberoERC1155_01.sol";
import "./LiberoMintFactory721_01.sol";
import "./LiberoMintFactory1155_01.sol";
import "./Ticketing_01.sol";
import "./ManifoldBurnable.sol";

uint constant IF_NONE = 0;
uint constant IF_ERC721 = 1;
uint constant IF_ERC1155 = 2;
uint constant IF_MANIFOLD1155 = 3;

uint256 constant NO_REWARD = uint256(int256(-1));

library LiberoRewards_01 {
    struct Raffle {
        address organizer;
        address rewardContract; // for transfer
        address mintContract; // for mint
        uint32 availableRewards; // rewards need to be supplied and checked before seedRaffle
        uint8 rewardIf;
        Reward[] rewards; // supplied later
        // all requirements have burn tokens, for no burn we use IF_NONE
        Requirement[] requirements;
        uint256 startAt;
        uint256 endAt;
        uint256 raffleAt;
        // fees
        uint256 sysTicketPrice;
        uint16 ownerSysFeePct;
        uint16 ownerFeePct;
        uint16 ownerTipPct;
        uint256 tips;
        uint256 fees;
        Ticketing_01 tickets;
        // pick
        bool prngInitialized;
        uint256 prngState;
        uint256 nextRewardIx; // does not include skipped
        uint256 totalTickets;
        uint256 totalRewards; // this takes into account # of tickets, can't be higher
        uint32 maxRewardsPerWallet;
        uint256 pickedRewards; // total picked counter
        WinningTicket[] winningTickets;
        // distribute rewards - only matters for awartTokenIds, for mint is myst always be set
        bool shouldDistributeRewards;
        uint256 distributeNextIx; // includes skipped
        // refund non wining tickets in rounds before payout
        bool shouldRefundNonWinning;
        uint256 refundedPriorityIx; // ix in validated priority tickets that are refunded (wining dont get a refund)
        uint256 refundedIx; // ix in validated normal tickets that are refunded (wining dont get a refund)
        bool finished;
    }

    // separate struct, not in raffle info as it cant be returned from info method
    struct RaffleExt {
        mapping(address => uint32) rewardsPerWallet;
        mapping(uint256 => bool) winningTicketKeys; // track winning tickets to prevent refunds
    }

    event RaffleCreated(uint32 raffleNr, uint32 id);

    event Payment(
        uint32 raffleNr,
        address wallet,
        uint128 sysFee,
        uint128 ownerSysFee,
        uint128 tip,
        uint128 fee,
        bool refund
    );
    event TicketPicked(
        uint32 raffleNr,
        uint32 winSeqNr,
        uint32 drawIx,
        uint32 drawFrom,
        bool isSkipped,
        bool isPriority,
        uint256 rewardTokenId,
        uint16 rewardTokenAmount,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr
    );

    struct WinningTicket {
        Ticketing_01.Ticket ticket;
        Reward reward;
        bool skipped;
    }
    struct Reward {
        uint256 tokenId;
        uint16 tokenAmount; // for ERC1155
    }
    struct Requirement {
        uint8 burnIf;
        uint16 burnTokenAmount; // for ERC1155
        address burnContract;
        uint256 ticketPrice;
    }

    event RewardError(
        uint32 raffleNr,
        string error,
        string reason,
        uint256 rewardTokenId,
        uint16 rewardTokenAmount,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr
    );
    event RewardSuccessful(
        uint32 raffleNr,
        uint256 rewardTokenId,
        uint16 rewardTokenAmount,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr
    );
    event TicketRefundNonWinning(
        uint32 raffleNr,
        uint256 tokenId,
        address wallet,
        uint64 ticketId,
        uint16 ticketNr,
        uint8 reqNr,
        bool success,
        uint256 amount
    );

    function _rewardError(
        uint32 raffleNr,
        string memory message,
        string memory reason,
        WinningTicket memory winningTicket
    ) private {
        emit RewardError(
            raffleNr,
            message,
            reason,
            winningTicket.reward.tokenId,
            winningTicket.reward.tokenAmount,
            winningTicket.ticket.tokenId,
            winningTicket.ticket.wallet,
            winningTicket.ticket.ticketId,
            winningTicket.ticket.ticketNr,
            winningTicket.ticket.reqNr
        );
    }

    function ext_newRaffleValidateAndCheckSignature(
        uint32 id,
        uint256 payAmount,
        address organizer,
        uint32 totalTickets,
        uint32 totalPriorityTickets,
        uint32 maxTicketsPerWallet,
        uint32 maxRewardsPerWallet,
        uint32 availableRewards,
        uint32 startTokenId,
        uint32 endTokenId,
        uint8 rewardIf,
        address rewardContract,
        address existingMintContract,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        bool isWhitelistMint,
        bool shouldDistributeRewards,
        bool shouldRefundNonWinning,
        uint256 startAt,
        uint256 endAt,
        uint256 raffleAt,
        uint256 sysTicketPrice,
        uint16 ownerSysFeePct,
        uint16 ownerFeePct,
        uint16 ownerTipPct,
        LiberoRewards_01.Requirement[] memory requirements,
        bytes memory signature
    ) public returns (address recoveredSigner) {
        require(msg.value == payAmount, "MUST_PAY_EXACT_AMOUNT");
        require(
            (bytes(mintUri).length == 0 && rewardContract != address(0)) ||
                (bytes(mintUri).length > 0 && rewardContract == address(0)),
            "SET_EITHER_REWARD_OR_MINT"
        );
        require(availableRewards > 0, "MIN_1_REWARD");
        require(
            ownerSysFeePct >= 0 && ownerSysFeePct <= 100,
            "OWNER_SYS_FEE_INVALID"
        );
        require(ownerFeePct >= 0 && ownerFeePct <= 100, "OWNER_FEE_INVALID");
        require(ownerTipPct >= 0 && ownerTipPct <= 100, "OWNER_TIP_INVALID");

        require(endAt > block.timestamp, "SHOULD_END_IN_FUTURE");
        require(endAt > startAt, "END_SHOULD_BE_AFTER_START");
        require(raffleAt >= endAt, "RAFFLE_SHOULD_BE_AFTER_END");

        // signature check
        bytes memory packed = abi.encodePacked(
            id,
            payAmount,
            organizer,
            totalTickets,
            totalPriorityTickets,
            maxTicketsPerWallet,
            maxRewardsPerWallet,
            availableRewards,
            startTokenId,
            endTokenId,
            rewardIf,
            rewardContract,
            existingMintContract,
            mintUri,
            mintName,
            mintSymbol,
            isWhitelistMint,
            shouldDistributeRewards,
            shouldRefundNonWinning,
            startAt,
            endAt,
            raffleAt,
            sysTicketPrice,
            ownerSysFeePct,
            ownerFeePct,
            ownerTipPct
        );
        for (uint256 i = 0; i < requirements.length; i++) {
            packed = abi.encodePacked(
                packed,
                requirements[i].burnIf,
                requirements[i].burnTokenAmount,
                requirements[i].burnContract,
                requirements[i].ticketPrice
            );
        }
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            packed
        );
        recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
    }

    function ext_buyTicketsValidateAndCheckSignature(
        uint32 raffleNr,
        Raffle storage activeRaffle,
        Ticketing_01.Ticket[] calldata toBuy,
        Ticketing_01.Ticket[] calldata toReturn,
        uint256 tip,
        bytes memory signature
    )
        public
        returns (
            address recoveredSigner,
            uint256 netPayAmount,
            uint256 netRefundAmount
        )
    {
        require(
            block.timestamp >= activeRaffle.startAt &&
                block.timestamp < activeRaffle.endAt,
            "TICKET_SALE_NOT_ACTIVE"
        );

        uint256 expectedPayAmount = 0;
        uint256 expectedRefundAmount = 0;
        netPayAmount = 0;
        netRefundAmount = 0;
        for (uint256 i = 0; i < toBuy.length; i++) {
            uint8 reqNr = toBuy[i].reqNr;
            require(
                reqNr < activeRaffle.requirements.length,
                "BUY_REQUIREMENT_IX_NOT_FOUND"
            );
            uint256 price = activeRaffle.requirements[reqNr].ticketPrice;
            expectedPayAmount += price;
        }
        for (uint256 i = 0; i < toReturn.length; i++) {
            uint8 reqNr = toReturn[i].reqNr;
            require(
                reqNr < activeRaffle.requirements.length,
                "RETURN_REQUIREMENT_IX_NOT_FOUND"
            );
            uint256 price = activeRaffle.requirements[reqNr].ticketPrice;
            expectedRefundAmount += price;
        }
        if (expectedPayAmount > expectedRefundAmount) {
            netPayAmount = expectedPayAmount - expectedRefundAmount;
        } else {
            netRefundAmount = expectedRefundAmount - expectedPayAmount;
        }

        require(
            msg.value ==
                netPayAmount +
                    (toBuy.length * activeRaffle.sysTicketPrice) +
                    tip,
            "INVALID_PAYMENT_FOR_TICKETS"
        );

        bytes memory packed = abi.encodePacked(raffleNr);
        for (uint256 i = 0; i < toBuy.length; i++) {
            require(
                msg.sender == address(toBuy[i].wallet),
                "MUST_BUY_TICKET_FOR_SELF"
            );
            require(toBuy[i].valid, "MUST_BUY_VALID_TICKET");
            packed = abi.encodePacked(
                packed,
                toBuy[i].tokenId,
                toBuy[i].wallet,
                toBuy[i].ticketId,
                toBuy[i].ticketNr,
                toBuy[i].reqNr,
                toBuy[i].isPriority,
                toBuy[i].valid
            );
        }
        for (uint256 i = 0; i < toReturn.length; i++) {
            require(
                msg.sender == address(toReturn[i].wallet),
                "MUST_RETURN_TICKET_FROM_SELF"
            );
            require(!toReturn[i].valid, "MUST_RETURN_NOT_VALID_TICKET");
            packed = abi.encodePacked(
                packed,
                toReturn[i].tokenId,
                toReturn[i].wallet,
                toReturn[i].ticketId,
                toReturn[i].ticketNr,
                toReturn[i].reqNr,
                toReturn[i].isPriority,
                toReturn[i].valid
            );
        }
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            packed
        );
        recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
    }

    function ext_burnRewardIxInternal(
        uint32 raffleNr,
        WinningTicket calldata winningTicket,
        Requirement[] calldata requirements
    ) public returns (bool success) {
        if (!winningTicket.skipped) {
            success = true;
            if (requirements.length > 0) {
                uint8 reqNr = winningTicket.ticket.reqNr;
                if (reqNr <= requirements.length) {
                    Requirement memory requirement = requirements[reqNr];

                    if (requirement.burnIf == IF_ERC721) {
                        if (winningTicket.ticket.reqNr >= requirements.length) {
                            success = false;
                            _rewardError(
                                raffleNr,
                                "burn.erc721.error",
                                "TICKET_BURN_TOKEN_NOT_FOUND",
                                winningTicket
                            );
                        } else {
                            ERC721Burnable burn721 = ERC721Burnable(
                                requirements[winningTicket.ticket.reqNr]
                                    .burnContract
                            );
                            try
                                burn721.burn(winningTicket.ticket.tokenId)
                            {} catch Error(string memory reason) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc721.error",
                                    reason,
                                    winningTicket
                                );
                            } catch (bytes memory lowLevelData) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc721.error.0",
                                    string(lowLevelData),
                                    winningTicket
                                );
                            }
                        }
                    } else if (requirement.burnIf == IF_ERC1155) {
                        if (winningTicket.ticket.reqNr >= requirements.length) {
                            success = false;
                            _rewardError(
                                raffleNr,
                                "burn.erc1155.error",
                                "TICKET_BURN_TOKEN_NOT_FOUND",
                                winningTicket
                            );
                        } else {
                            ERC1155Burnable burn1155 = ERC1155Burnable(
                                requirements[winningTicket.ticket.reqNr]
                                    .burnContract
                            );
                            try
                                burn1155.burn(
                                    address(winningTicket.ticket.wallet),
                                    winningTicket.ticket.tokenId,
                                    requirements[winningTicket.ticket.reqNr]
                                        .burnTokenAmount
                                )
                            {} catch Error(string memory reason) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc1155.error",
                                    reason,
                                    winningTicket
                                );
                            } catch (bytes memory lowLevelData) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.erc1155.error.0",
                                    string(lowLevelData),
                                    winningTicket
                                );
                            }
                        }
                    } else if (requirement.burnIf == IF_MANIFOLD1155) {
                        if (winningTicket.ticket.reqNr >= requirements.length) {
                            success = false;
                            _rewardError(
                                raffleNr,
                                "burn.erc1155.error",
                                "TICKET_BURN_TOKEN_NOT_FOUND",
                                winningTicket
                            );
                        } else {
                            ManifoldERC1155Burnable burn1155 = ManifoldERC1155Burnable(
                                    requirements[winningTicket.ticket.reqNr]
                                        .burnContract
                                );
                            uint256[] memory ids = new uint256[](1);
                            uint256[] memory values = new uint256[](1);
                            ids[0] = winningTicket.ticket.tokenId;
                            values[0] = requirements[winningTicket.ticket.reqNr]
                                .burnTokenAmount;
                            try
                                burn1155.burn(
                                    address(winningTicket.ticket.wallet),
                                    ids,
                                    values
                                )
                            {} catch Error(string memory reason) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.manifold1155.error",
                                    reason,
                                    winningTicket
                                );
                            } catch (bytes memory lowLevelData) {
                                success = false;
                                _rewardError(
                                    raffleNr,
                                    "burn.manifold1155.error.0",
                                    string(lowLevelData),
                                    winningTicket
                                );
                            }
                        }
                    }
                } else {
                    success = false;
                    _rewardError(
                        raffleNr,
                        "burn.token.error",
                        "REQ_BURN_TOKEN_NOT_FOUND",
                        winningTicket
                    );
                }
            }
        }
    }

    function ext_sendRewardIxInternal(
        uint32 raffleNr,
        WinningTicket calldata winningTicket,
        uint8 rewardIf,
        address rewardContract,
        address mintContract,
        address organizer
    ) public returns (bool success) {
        if (!winningTicket.skipped) {
            success = true;
            // mint
            if (mintContract != address(0)) {
                if (rewardIf == IF_ERC721) {
                    LiberoERC721_01 mint721 = LiberoERC721_01(mintContract);
                    try
                        mint721.mintTo(
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint721.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint721.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                } else if (rewardIf == IF_ERC1155) {
                    LiberoERC1155_01 mint1155 = LiberoERC1155_01(mintContract);
                    try
                        mint1155.mint(
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId,
                            winningTicket.reward.tokenAmount,
                            ""
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint1155.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "mint1155.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                }
            } else if (rewardContract != address(0)) {
                // transfer reward
                if (rewardIf == IF_ERC721) {
                    IERC721 reward721 = IERC721(rewardContract);
                    try
                        reward721.safeTransferFrom(
                            organizer,
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer721.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer721.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                } else if (rewardIf == IF_ERC1155) {
                    IERC1155 reward1155 = IERC1155(rewardContract);
                    try
                        reward1155.safeTransferFrom(
                            organizer,
                            address(winningTicket.ticket.wallet),
                            winningTicket.reward.tokenId,
                            winningTicket.reward.tokenAmount,
                            ""
                        )
                    {} catch Error(string memory reason) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer1155.error",
                            reason,
                            winningTicket
                        );
                    } catch (bytes memory lowLevelData) {
                        success = false;
                        _rewardError(
                            raffleNr,
                            "transfer1155.error.0",
                            string(lowLevelData),
                            winningTicket
                        );
                    }
                }
            }
            if (success) {
                emit LiberoRewards_01.RewardSuccessful(
                    raffleNr,
                    winningTicket.reward.tokenId,
                    winningTicket.reward.tokenAmount,
                    winningTicket.ticket.tokenId,
                    winningTicket.ticket.wallet,
                    winningTicket.ticket.ticketId,
                    winningTicket.ticket.ticketNr,
                    winningTicket.ticket.reqNr
                );
            }
        }
    }

    function ext_approveAwardInternal(
        uint8 rewardIf,
        address rewardContract,
        address organizer,
        Reward[] memory rewards
    ) public view {
        bool approved = false;
        // allow transfer of each token
        if (rewardIf == IF_ERC721) {
            IERC721 erc721 = IERC721(rewardContract);
            if (erc721.isApprovedForAll(organizer, address(this))) {
                approved = true;
            } else {
                for (uint256 i = 0; i < rewards.length; i++) {
                    if (
                        address(this) == erc721.getApproved(rewards[i].tokenId)
                    ) {
                        approved = true;
                    }
                }
            }
        } else if (rewardIf == IF_ERC1155) {
            IERC1155 erc1155 = IERC1155(rewardContract);
            if (erc1155.isApprovedForAll(organizer, address(this))) {
                approved = true;
            }
        }
        require(approved, "REWARD_NOT_APPROVED");
    }

    function ext_batchMint(
        uint8 rewardIf,
        address mintContract,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts
    ) public {
        require(to.length == tokenIds.length, "BATCH_MINT_L1");
        require(to.length == tokenAmounts.length, "BATCH_MINT_L2");
        if (mintContract != address(0)) {
            if (rewardIf == IF_ERC721) {
                LiberoERC721_01 mint721 = LiberoERC721_01(mintContract);
                for (uint256 i = 0; i < to.length; i++) {
                    mint721.mintTo(to[i], tokenIds[i]);
                }
            } else if (rewardIf == IF_ERC1155) {
                LiberoERC1155_01 mint1155 = LiberoERC1155_01(mintContract);
                for (uint256 i = 0; i < to.length; i++) {
                    mint1155.mint(to[i], tokenIds[i], tokenAmounts[i], "");
                }
            }
        }
    }

    function ext_batchMintCheckSignature(
        uint32 raffleNr,
        address[] memory to,
        uint256[] memory tokenIds,
        uint256[] memory tokenAmounts,
        bytes memory signature
    ) public pure returns (address recoveredSigner) {
        require(to.length == tokenIds.length, "BATCH_MINT_L1");
        require(to.length == tokenAmounts.length, "BATCH_MINT_L2");

        bytes memory packed = abi.encodePacked(raffleNr);

        for (uint256 i = 0; i < to.length; i++) {
            packed = abi.encodePacked(
                packed,
                to[i],
                tokenIds[i],
                tokenAmounts[i]
            );
        }

        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            packed
        );
        recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
    }

    function ext_payAny(
        address to,
        uint256 amount,
        uint32 gasLimit
    ) public returns (bool) {
        // payable(ticket.wallet).transfer(price);
        // return true;
        (bool sent, ) = payable(to).call{gas: gasLimit, value: amount}("");
        return sent;
    }

    function ext_newRaffleDeploy(
        address manager,
        address organizer,
        uint8 rewardIf,
        address rewardContract,
        address existingMintContract,
        uint256 startTokenId,
        uint256 endTokenId,
        string memory mintUri,
        string memory mintName,
        string memory mintSymbol,
        bool isWhitelistMint,
        bool shouldDistributeRewards,
        LiberoMintFactory721_01 _liberoMintFactory721,
        LiberoMintFactory1155_01 _liberoMintFactory1155
    ) public returns (address mintContract) {
        if (rewardContract == address(0)) {
            require(
                shouldDistributeRewards && rewardIf != IF_NONE,
                "MINT_REQUIRES_DISTRIBUTION_OF_REWARDS"
            );
            if (existingMintContract == address(0)) {
                require(
                    bytes(mintSymbol).length > 0,
                    "MINT_REQUIRESTOKEN_SYMBOL"
                );
                require(bytes(mintName).length > 0, "MINT_REQUIRESTOKEN_NAME");
                if (isWhitelistMint) {
                    require(rewardIf == IF_ERC721, "WHITELIST_IS_ERC721");
                }
                if (rewardIf == IF_ERC721) {
                    if (isWhitelistMint) {
                        LiberoWL_01 mintable = _liberoMintFactory721
                            .deployLiberoWL(
                                mintUri,
                                mintName,
                                mintSymbol,
                                organizer,
                                manager
                            );
                        mintContract = address(mintable);
                    } else {
                        LiberoERC721_01 mintable = _liberoMintFactory721
                            .deployLiberoERC721(
                                startTokenId,
                                endTokenId,
                                mintUri,
                                mintName,
                                mintSymbol,
                                organizer,
                                manager
                            );
                        mintContract = address(mintable);
                    }
                } else if (rewardIf == IF_ERC1155) {
                    LiberoERC1155_01 mintable = _liberoMintFactory1155
                        .deployLiberoERC1155(
                            startTokenId,
                            endTokenId,
                            mintUri,
                            mintName,
                            mintSymbol,
                            organizer,
                            manager
                        );
                    mintContract = address(mintable);
                }
            } else {
                if (rewardIf == IF_ERC721) {
                    if (isWhitelistMint) {
                        require(false, "WL_MINT_PREVENT_EXISTING");
                    } else {
                        LiberoERC721_01 nft = LiberoERC721_01(
                            existingMintContract
                        );
                        nft.newEdition(startTokenId, endTokenId, mintUri);
                        emit LiberoMintFactory721_01.ERC721Deployed(
                            existingMintContract
                        );
                    }
                    mintContract = existingMintContract;
                } else if (rewardIf == IF_ERC1155) {
                    LiberoERC1155_01 nft = LiberoERC1155_01(
                        existingMintContract
                    );
                    nft.newEdition(startTokenId, endTokenId, mintUri);
                    emit LiberoMintFactory1155_01.ERC1155Deployed(
                        existingMintContract
                    );
                    mintContract = existingMintContract;
                }
            }
        }
    }
}