Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

import '../../CyberDropBase.sol';

abstract contract LuxContract {
  function mintThroughBurn(
    address newOwner,
    uint256 tokenId,
    uint256 amount
  ) public virtual;
}

contract CyberDestinationUtilityFactoryFacet is CyberDropBase {
  function burnTransfer(uint256 quantity, bool isLux) public {
    // definitions
    uint256 toBurn = isLux ? quantity * 20 : quantity * 2;
    ERC1155 lootPodContract = ERC1155(0xb7bE4001BfF2c5F4a61dd2435E4c9A19D8d12343); // replace with 0xb7be4001bff2c5f4a61dd2435e4c9a19d8d12343

    // check balance
    require(balanceOf(msg.sender, 5) >= toBurn, 'NS'); // replace with 5
    require(lootPodContract.balanceOf(msg.sender, 1) >= toBurn, 'NR');

    // burn mechanisms
    lootPodContract.safeTransferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD, 1, toBurn, '');
    _burn(msg.sender, 5, toBurn); // replace with 5

    // mint new token
    LuxContract luxPodContract = LuxContract(0x895554bc4F48fe1c2bf5C198bFA3513Da538f86b); // replace w new rtfkt contract
    luxPodContract.mintThroughBurn(msg.sender, isLux ? 2 : 1, quantity);
  }

  function updateTokenURI(uint256 tokenId, string memory _tokenURI) public {
    require(msg.sender == LibAppStorage.layout().manager, 'NM');

    setTokenURI(tokenId, _tokenURI);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

import '@openzeppelin/contracts/utils/Context.sol';
import './BaseRelayRecipientStorage.sol';

/**
 * A base contract to be inherited by any contract that want to receive relayed transactions
 * A subclass must use "_msgSender()" instead of "msg.sender"
 */

abstract contract BaseRelayRecipient is Context {
  /*
   * require a function to be called through GSN only
   */
  //  modifier trustedForwarderOnly() {
  //    require(msg.sender == address(s.trustedForwarder), "Function can only be called through the trusted Forwarder");
  //    _;
  //  }

  function isTrustedForwarder(address forwarder) public view returns (bool) {
    return forwarder == BaseRelayRecipientStorage.layout().trustedForwarder;
  }

  /**
   * return the sender of this call.
   * if the call came through our trusted forwarder, return the original sender.
   * otherwise, return `msg.sender`.
   * should be used in the contract anywhere instead of msg.sender
   */
  function _msgSender() internal view virtual override returns (address ret) {
    if (msg.data.length >= 24 && isTrustedForwarder(msg.sender)) {
      // At this point we know that the sender is a trusted forwarder,
      // so we trust that the last bytes of msg.data are the verified sender address.
      // extract sender address from the end of msg.data
      assembly {
        ret := shr(96, calldataload(sub(calldatasize(), 20)))
      }
    } else {
      return msg.sender;
    }
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

library BaseRelayRecipientStorage {
  bytes32 internal constant STORAGE_SLOT = keccak256('diamond.storage.BaseRelayRecipientStorage');

  struct Layout {
    /*
     * Forwarder singleton we accept calls from
     */
    address trustedForwarder;
  }

  function layout() internal pure returns (Layout storage lay) {
    bytes32 slot = STORAGE_SLOT;
    assembly {
      lay.slot := slot
    }
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/Counters.sol';
import '@solidstate/contracts/token/ERC1155/IERC1155.sol';
import './BaseRelayRecipient/BaseRelayRecipient.sol';
import './BaseRelayRecipient/BaseRelayRecipientStorage.sol';
import './Diamond/LibDiamond.sol';
import './ERC1155URI/ERC1155URI.sol';

import './libraries/LibAppStorage.sol';

contract CyberTokenBase is BaseRelayRecipient, ERC1155URI {
  using ECDSA for bytes32;
  using Counters for Counters.Counter;

  event Minted(address indexed account, uint256 indexed tokenId, uint256 indexed amount);

  function initialize(
    string memory _uri,
    address _manager,
    address _trustedForwarder,
    address _opensea,
    address _oncyber
  ) public virtual {
    require(LibDiamond.diamondStorage().contractOwner == msg.sender, 'NO');

    BaseRelayRecipientStorage.layout().trustedForwarder = _trustedForwarder;
    LibDiamond.diamondStorage().supportedInterfaces[type(IERC1155).interfaceId] = true;
    setURI(_uri);
    LibAppStorage.layout().manager = _manager;
    LibAppStorage.layout().opensea = _opensea;
    LibAppStorage.layout().oncyber = _oncyber;
  }

  function totalSupply() public view returns (uint256) {
    return LibAppStorage.layout().totalSupply.current();
  }

  function manager() public view returns (address) {
    return LibAppStorage.layout().manager;
  }

  function oncyber() public view returns (address) {
    return LibAppStorage.layout().oncyber;
  }

  function minterNonce(address _minter) public view returns (uint256) {
    return LibAppStorage.layout().minterNonce[_minter].current();
  }
}

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

pragma solidity ^0.8.0;

import "../Strings.sol";

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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC1155Internal } from './IERC1155Internal.sol';
import { IERC165 } from '../../introspection/IERC165.sol';

/**
 * @notice ERC1155 interface
 * @dev see https://github.com/ethereum/EIPs/issues/1155
 */
interface IERC1155 is IERC1155Internal, IERC165 {
    /**
     * @notice query the balance of given token held by given address
     * @param account address to query
     * @param id token to query
     * @return token balance
     */
    function balanceOf(address account, uint256 id)
        external
        view
        returns (uint256);

    /**
     * @notice query the balances of given tokens held by given addresses
     * @param accounts addresss to query
     * @param ids tokens to query
     * @return token balances
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @notice query approval status of given operator with respect to given address
     * @param account address to query for approval granted
     * @param operator address to query for approval received
     * @return whether operator is approved to spend tokens held by account
     */
    function isApprovedForAll(address account, address operator)
        external
        view
        returns (bool);

    /**
     * @notice grant approval to or revoke approval from given operator to spend held tokens
     * @param operator address whose approval status to update
     * @param status whether operator should be considered approved
     */
    function setApprovalForAll(address operator, bool status) external;

    /**
     * @notice transfer tokens between given addresses, checking for ERC1155Receiver implementation if applicable
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @notice transfer batch of tokens between given addresses, checking for ERC1155Receiver implementation if applicable
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to transfer
     * @param data data payload
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;

/******************************************************************************\
* Author: Nick Mudge <nick@perfectabstractions.com> (https://twitter.com/mudgen)
* EIP-2535 Diamond Standard: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

library LibDiamond {
  bytes32 public constant DIAMOND_STORAGE_POSITION = keccak256('diamond.standard.diamond.storage');

  struct FacetAddressAndPosition {
    address facetAddress;
    uint16 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
  }

  struct FacetFunctionSelectors {
    bytes4[] functionSelectors;
    uint16 facetAddressPosition; // position of facetAddress in facetAddresses array
  }

  struct DiamondStorage {
    // maps function selector to the facet address and
    // the position of the selector in the facetFunctionSelectors.selectors array
    mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;
    // maps facet addresses to function selectors
    mapping(address => FacetFunctionSelectors) facetFunctionSelectors;
    // facet addresses
    address[] facetAddresses;
    // Used to query if a contract implements an interface.
    // Used to implement ERC-165.
    mapping(bytes4 => bool) supportedInterfaces;
    // owner of the contract
    address contractOwner;
  }

  function diamondStorage() internal pure returns (DiamondStorage storage ds) {
    bytes32 position = DIAMOND_STORAGE_POSITION;
    assembly {
      ds.slot := position
    }
  }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

import '@solidstate/contracts/token/ERC1155/ERC1155.sol';
import './ERC1155URIStorage.sol';

abstract contract ERC1155URI is ERC1155 {
  function uri(uint256 _tokenId) public view virtual override returns (string memory) {
    string memory tokenURI = ERC1155URIStorage.layout().tokenURIs[_tokenId];
    require(bytes(tokenURI).length != 0, 'ERC1155URI: tokenId not exist');
    return string(abi.encodePacked(ERC1155URIStorage.layout().uri, tokenURI));
  }

  function setURI(string memory newUri) internal virtual {
    ERC1155URIStorage.layout().uri = newUri;
  }

  function setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
    ERC1155URIStorage.layout().tokenURIs[tokenId] = _tokenURI;
  }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

import '@openzeppelin/contracts/utils/Counters.sol';

//

library LibAppStorage {
  bytes32 public constant STORAGE_SLOT = keccak256('app.storage');

  struct Layout {
    address manager;
    address opensea;
    Counters.Counter totalSupply;
    mapping(address => Counters.Counter) minterNonce;
    address oncyber;
  }

  function layout() internal pure returns (Layout storage lay) {
    bytes32 slot = STORAGE_SLOT;
    assembly {
      lay.slot := slot
    }
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC165 } from '../../introspection/IERC165.sol';

/**
 * @notice Partial ERC1155 interface needed by internal functions
 */
interface IERC1155Internal {
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC165 interface registration interface
 * @dev see https://eips.ethereum.org/EIPS/eip-165
 */
interface IERC165 {
    /**
     * @notice query whether contract has registered support for given interface
     * @param interfaceId interface id
     * @return bool whether interface is supported
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { ERC165 } from '../../introspection/ERC165.sol';
import { ERC1155Base, ERC1155BaseInternal } from './base/ERC1155Base.sol';
import { ERC1155Enumerable } from './enumerable/ERC1155Enumerable.sol';
import { ERC1155Metadata } from './metadata/ERC1155Metadata.sol';

/**
 * @title SolidState ERC1155 implementation
 */
abstract contract ERC1155 is
    ERC1155Base,
    ERC1155Enumerable,
    ERC1155Metadata,
    ERC165
{
    /**
     * @inheritdoc ERC1155BaseInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override(ERC1155BaseInternal, ERC1155Enumerable) {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

library ERC1155URIStorage {
  bytes32 internal constant STORAGESLOT = keccak256('diamond.storage.ERC1155URI');

  struct Layout {
    mapping(uint256 => string) tokenURIs;
    string uri;
  }

  function layout() internal pure returns (Layout storage lay) {
    bytes32 slot = STORAGESLOT;
    assembly {
      lay.slot := slot
    }
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC165 } from './IERC165.sol';
import { ERC165Storage } from './ERC165Storage.sol';

/**
 * @title ERC165 implementation
 */
abstract contract ERC165 is IERC165 {
    using ERC165Storage for ERC165Storage.Layout;

    /**
     * @inheritdoc IERC165
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override
        returns (bool)
    {
        return ERC165Storage.layout().isSupportedInterface(interfaceId);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC1155 } from '../IERC1155.sol';
import { IERC1155Receiver } from '../IERC1155Receiver.sol';
import { ERC1155BaseInternal, ERC1155BaseStorage } from './ERC1155BaseInternal.sol';

/**
 * @title Base ERC1155 contract
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
abstract contract ERC1155Base is IERC1155, ERC1155BaseInternal {
    /**
     * @inheritdoc IERC1155
     */
    function balanceOf(address account, uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _balanceOf(account, id);
    }

    /**
     * @inheritdoc IERC1155
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(
            accounts.length == ids.length,
            'ERC1155: accounts and ids length mismatch'
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

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

        unchecked {
            for (uint256 i; i < accounts.length; i++) {
                require(
                    accounts[i] != address(0),
                    'ERC1155: batch balance query for the zero address'
                );
                batchBalances[i] = balances[ids[i]][accounts[i]];
            }
        }

        return batchBalances;
    }

    /**
     * @inheritdoc IERC1155
     */
    function isApprovedForAll(address account, address operator)
        public
        view
        virtual
        override
        returns (bool)
    {
        return ERC1155BaseStorage.layout().operatorApprovals[account][operator];
    }

    /**
     * @inheritdoc IERC1155
     */
    function setApprovalForAll(address operator, bool status)
        public
        virtual
        override
    {
        require(
            msg.sender != operator,
            'ERC1155: setting approval status for self'
        );
        ERC1155BaseStorage.layout().operatorApprovals[msg.sender][
            operator
        ] = status;
        emit ApprovalForAll(msg.sender, operator, status);
    }

    /**
     * @inheritdoc IERC1155
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == msg.sender || isApprovedForAll(from, msg.sender),
            'ERC1155: caller is not owner nor approved'
        );
        _safeTransfer(msg.sender, from, to, id, amount, data);
    }

    /**
     * @inheritdoc IERC1155
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == msg.sender || isApprovedForAll(from, msg.sender),
            'ERC1155: caller is not owner nor approved'
        );
        _safeTransferBatch(msg.sender, from, to, ids, amounts, data);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../../utils/EnumerableSet.sol';
import { ERC1155Base, ERC1155BaseInternal } from '../base/ERC1155Base.sol';
import { IERC1155Enumerable } from './IERC1155Enumerable.sol';
import { ERC1155EnumerableInternal, ERC1155EnumerableStorage } from './ERC1155EnumerableInternal.sol';

/**
 * @title ERC1155 implementation including enumerable and aggregate functions
 */
abstract contract ERC1155Enumerable is
    IERC1155Enumerable,
    ERC1155Base,
    ERC1155EnumerableInternal
{
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function totalSupply(uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return ERC1155EnumerableStorage.layout().totalSupply[id];
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function totalHolders(uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return ERC1155EnumerableStorage.layout().accountsByToken[id].length();
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function accountsByToken(uint256 id)
        public
        view
        virtual
        override
        returns (address[] memory)
    {
        EnumerableSet.AddressSet storage accounts = ERC1155EnumerableStorage
            .layout()
            .accountsByToken[id];

        address[] memory addresses = new address[](accounts.length());

        for (uint256 i; i < accounts.length(); i++) {
            addresses[i] = accounts.at(i);
        }

        return addresses;
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function tokensByAccount(address account)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        EnumerableSet.UintSet storage tokens = ERC1155EnumerableStorage
            .layout()
            .tokensByAccount[account];

        uint256[] memory ids = new uint256[](tokens.length());

        for (uint256 i; i < tokens.length(); i++) {
            ids[i] = tokens.at(i);
        }

        return ids;
    }

    /**
     * @notice ERC1155 hook: update aggregate values
     * @inheritdoc ERC1155EnumerableInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        internal
        virtual
        override(ERC1155BaseInternal, ERC1155EnumerableInternal)
    {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { UintUtils } from '../../../utils/UintUtils.sol';
import { IERC1155Metadata } from './IERC1155Metadata.sol';
import { ERC1155MetadataInternal } from './ERC1155MetadataInternal.sol';
import { ERC1155MetadataStorage } from './ERC1155MetadataStorage.sol';

/**
 * @notice ERC1155 metadata extensions
 */
abstract contract ERC1155Metadata is IERC1155Metadata, ERC1155MetadataInternal {
    using UintUtils for uint256;

    /**
     * @notice inheritdoc IERC1155Metadata
     */
    function uri(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        ERC1155MetadataStorage.Layout storage l = ERC1155MetadataStorage
            .layout();

        string memory tokenIdURI = l.tokenURIs[tokenId];
        string memory baseURI = l.baseURI;

        if (bytes(baseURI).length == 0) {
            return tokenIdURI;
        } else if (bytes(tokenIdURI).length > 0) {
            return string(abi.encodePacked(baseURI, tokenIdURI));
        } else {
            return string(abi.encodePacked(baseURI, tokenId.toString()));
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library ERC165Storage {
    struct Layout {
        mapping(bytes4 => bool) supportedInterfaces;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC165');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function isSupportedInterface(Layout storage l, bytes4 interfaceId)
        internal
        view
        returns (bool)
    {
        return l.supportedInterfaces[interfaceId];
    }

    function setSupportedInterface(
        Layout storage l,
        bytes4 interfaceId,
        bool status
    ) internal {
        require(interfaceId != 0xffffffff, 'ERC165: invalid interface id');
        l.supportedInterfaces[interfaceId] = status;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC165 } from '../../introspection/IERC165.sol';

/**
 * @title ERC1155 transfer receiver interface
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @notice validate receipt of ERC1155 transfer
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param id token ID received
     * @param value quantity of tokens received
     * @param data data payload
     * @return function's own selector if transfer is accepted
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @notice validate receipt of ERC1155 batch transfer
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param ids token IDs received
     * @param values quantities of tokens received
     * @param data data payload
     * @return function's own selector if transfer is accepted
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { AddressUtils } from '../../../utils/AddressUtils.sol';
import { IERC1155Internal } from '../IERC1155Internal.sol';
import { IERC1155Receiver } from '../IERC1155Receiver.sol';
import { ERC1155BaseStorage } from './ERC1155BaseStorage.sol';

/**
 * @title Base ERC1155 internal functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
abstract contract ERC1155BaseInternal is IERC1155Internal {
    using AddressUtils for address;

    /**
     * @notice query the balance of given token held by given address
     * @param account address to query
     * @param id token to query
     * @return token balance
     */
    function _balanceOf(address account, uint256 id)
        internal
        view
        virtual
        returns (uint256)
    {
        require(
            account != address(0),
            'ERC1155: balance query for the zero address'
        );
        return ERC1155BaseStorage.layout().balances[id][account];
    }

    /**
     * @notice mint given quantity of tokens for given address
     * @dev ERC1155Receiver implementation is not checked
     * @param account beneficiary of minting
     * @param id token ID
     * @param amount quantity of tokens to mint
     * @param data data payload
     */
    function _mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(account != address(0), 'ERC1155: mint to the zero address');

        _beforeTokenTransfer(
            msg.sender,
            address(0),
            account,
            _asSingletonArray(id),
            _asSingletonArray(amount),
            data
        );

        mapping(address => uint256) storage balances = ERC1155BaseStorage
            .layout()
            .balances[id];
        balances[account] += amount;

        emit TransferSingle(msg.sender, address(0), account, id, amount);
    }

    /**
     * @notice mint given quantity of tokens for given address
     * @param account beneficiary of minting
     * @param id token ID
     * @param amount quantity of tokens to mint
     * @param data data payload
     */
    function _safeMint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        _mint(account, id, amount, data);

        _doSafeTransferAcceptanceCheck(
            msg.sender,
            address(0),
            account,
            id,
            amount,
            data
        );
    }

    /**
     * @notice mint batch of tokens for given address
     * @dev ERC1155Receiver implementation is not checked
     * @param account beneficiary of minting
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to mint
     * @param data data payload
     */
    function _mintBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(account != address(0), 'ERC1155: mint to the zero address');
        require(
            ids.length == amounts.length,
            'ERC1155: ids and amounts length mismatch'
        );

        _beforeTokenTransfer(
            msg.sender,
            address(0),
            account,
            ids,
            amounts,
            data
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        for (uint256 i; i < ids.length; i++) {
            balances[ids[i]][account] += amounts[i];
        }

        emit TransferBatch(msg.sender, address(0), account, ids, amounts);
    }

    /**
     * @notice mint batch of tokens for given address
     * @param account beneficiary of minting
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to mint
     * @param data data payload
     */
    function _safeMintBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _mintBatch(account, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(
            msg.sender,
            address(0),
            account,
            ids,
            amounts,
            data
        );
    }

    /**
     * @notice burn given quantity of tokens held by given address
     * @param account holder of tokens to burn
     * @param id token ID
     * @param amount quantity of tokens to burn
     */
    function _burn(
        address account,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(account != address(0), 'ERC1155: burn from the zero address');

        _beforeTokenTransfer(
            msg.sender,
            account,
            address(0),
            _asSingletonArray(id),
            _asSingletonArray(amount),
            ''
        );

        mapping(address => uint256) storage balances = ERC1155BaseStorage
            .layout()
            .balances[id];

        unchecked {
            require(
                balances[account] >= amount,
                'ERC1155: burn amount exceeds balances'
            );
            balances[account] -= amount;
        }

        emit TransferSingle(msg.sender, account, address(0), id, amount);
    }

    /**
     * @notice burn given batch of tokens held by given address
     * @param account holder of tokens to burn
     * @param ids token IDs
     * @param amounts quantities of tokens to burn
     */
    function _burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(account != address(0), 'ERC1155: burn from the zero address');
        require(
            ids.length == amounts.length,
            'ERC1155: ids and amounts length mismatch'
        );

        _beforeTokenTransfer(msg.sender, account, address(0), ids, amounts, '');

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        unchecked {
            for (uint256 i; i < ids.length; i++) {
                uint256 id = ids[i];
                require(
                    balances[id][account] >= amounts[i],
                    'ERC1155: burn amount exceeds balance'
                );
                balances[id][account] -= amounts[i];
            }
        }

        emit TransferBatch(msg.sender, account, address(0), ids, amounts);
    }

    /**
     * @notice transfer tokens between given addresses
     * @dev ERC1155Receiver implementation is not checked
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _transfer(
        address operator,
        address sender,
        address recipient,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(
            recipient != address(0),
            'ERC1155: transfer to the zero address'
        );

        _beforeTokenTransfer(
            operator,
            sender,
            recipient,
            _asSingletonArray(id),
            _asSingletonArray(amount),
            data
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        unchecked {
            uint256 senderBalance = balances[id][sender];
            require(
                senderBalance >= amount,
                'ERC1155: insufficient balances for transfer'
            );
            balances[id][sender] = senderBalance - amount;
        }

        balances[id][recipient] += amount;

        emit TransferSingle(operator, sender, recipient, id, amount);
    }

    /**
     * @notice transfer tokens between given addresses
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _safeTransfer(
        address operator,
        address sender,
        address recipient,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        _transfer(operator, sender, recipient, id, amount, data);

        _doSafeTransferAcceptanceCheck(
            operator,
            sender,
            recipient,
            id,
            amount,
            data
        );
    }

    /**
     * @notice transfer batch of tokens between given addresses
     * @dev ERC1155Receiver implementation is not checked
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _transferBatch(
        address operator,
        address sender,
        address recipient,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(
            recipient != address(0),
            'ERC1155: transfer to the zero address'
        );
        require(
            ids.length == amounts.length,
            'ERC1155: ids and amounts length mismatch'
        );

        _beforeTokenTransfer(operator, sender, recipient, ids, amounts, data);

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        for (uint256 i; i < ids.length; i++) {
            uint256 token = ids[i];
            uint256 amount = amounts[i];

            unchecked {
                uint256 senderBalance = balances[token][sender];
                require(
                    senderBalance >= amount,
                    'ERC1155: insufficient balances for transfer'
                );
                balances[token][sender] = senderBalance - amount;
            }

            balances[token][recipient] += amount;
        }

        emit TransferBatch(operator, sender, recipient, ids, amounts);
    }

    /**
     * @notice transfer batch of tokens between given addresses
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _safeTransferBatch(
        address operator,
        address sender,
        address recipient,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _transferBatch(operator, sender, recipient, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(
            operator,
            sender,
            recipient,
            ids,
            amounts,
            data
        );
    }

    /**
     * @notice wrap given element in array of length 1
     * @param element element to wrap
     * @return singleton array
     */
    function _asSingletonArray(uint256 element)
        private
        pure
        returns (uint256[] memory)
    {
        uint256[] memory array = new uint256[](1);
        array[0] = element;
        return array;
    }

    /**
     * @notice revert if applicable transfer recipient is not valid ERC1155Receiver
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155Received(
                    operator,
                    from,
                    id,
                    amount,
                    data
                )
            returns (bytes4 response) {
                require(
                    response == IERC1155Receiver.onERC1155Received.selector,
                    'ERC1155: ERC1155Receiver rejected tokens'
                );
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert('ERC1155: transfer to non ERC1155Receiver implementer');
            }
        }
    }

    /**
     * @notice revert if applicable transfer recipient is not valid ERC1155Receiver
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155BatchReceived(
                    operator,
                    from,
                    ids,
                    amounts,
                    data
                )
            returns (bytes4 response) {
                require(
                    response ==
                        IERC1155Receiver.onERC1155BatchReceived.selector,
                    'ERC1155: ERC1155Receiver rejected tokens'
                );
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert('ERC1155: transfer to non ERC1155Receiver implementer');
            }
        }
    }

    /**
     * @notice ERC1155 hook, called before all transfers including mint and burn
     * @dev function should be overridden and new implementation must call super
     * @dev called for both single and batch transfers
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library AddressUtils {
    function toString(address account) internal pure returns (string memory) {
        bytes32 value = bytes32(uint256(uint160(account)));
        bytes memory alphabet = '0123456789abcdef';
        bytes memory chars = new bytes(42);

        chars[0] = '0';
        chars[1] = 'x';

        for (uint256 i = 0; i < 20; i++) {
            chars[2 + i * 2] = alphabet[uint8(value[i + 12] >> 4)];
            chars[3 + i * 2] = alphabet[uint8(value[i + 12] & 0x0f)];
        }

        return string(chars);
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable account, uint256 amount) internal {
        (bool success, ) = account.call{ value: amount }('');
        require(success, 'AddressUtils: failed to send value');
    }

    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionCall(target, data, 'AddressUtils: failed low-level call');
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory error
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, error);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                'AddressUtils: failed low-level call with value'
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            'AddressUtils: insufficient balance for call'
        );
        return _functionCallWithValue(target, data, value, error);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) private returns (bytes memory) {
        require(
            isContract(target),
            'AddressUtils: function call to non-contract'
        );

        (bool success, bytes memory returnData) = target.call{ value: value }(
            data
        );

        if (success) {
            return returnData;
        } else if (returnData.length > 0) {
            assembly {
                let returnData_size := mload(returnData)
                revert(add(32, returnData), returnData_size)
            }
        } else {
            revert(error);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library ERC1155BaseStorage {
    struct Layout {
        mapping(uint256 => mapping(address => uint256)) balances;
        mapping(address => mapping(address => bool)) operatorApprovals;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Base');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Set implementation with enumeration functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license)
 */
library EnumerableSet {
    struct Set {
        bytes32[] _values;
        // 1-indexed to allow 0 to signify nonexistence
        mapping(bytes32 => uint256) _indexes;
    }

    struct Bytes32Set {
        Set _inner;
    }

    struct AddressSet {
        Set _inner;
    }

    struct UintSet {
        Set _inner;
    }

    function at(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, index);
    }

    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    function at(UintSet storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }

    function contains(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }

    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    function contains(UintSet storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    function indexOf(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (uint256)
    {
        return _indexOf(set._inner, value);
    }

    function indexOf(AddressSet storage set, address value)
        internal
        view
        returns (uint256)
    {
        return _indexOf(set._inner, bytes32(uint256(uint160(value))));
    }

    function indexOf(UintSet storage set, uint256 value)
        internal
        view
        returns (uint256)
    {
        return _indexOf(set._inner, bytes32(value));
    }

    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function add(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, value);
    }

    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    function remove(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    function remove(UintSet storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        require(
            set._values.length > index,
            'EnumerableSet: index out of bounds'
        );
        return set._values[index];
    }

    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    function _indexOf(Set storage set, bytes32 value)
        private
        view
        returns (uint256)
    {
        unchecked {
            return set._indexes[value] - 1;
        }
    }

    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    function _remove(Set storage set, bytes32 value) private returns (bool) {
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            uint256 index = valueIndex - 1;
            bytes32 last = set._values[set._values.length - 1];

            // move last value to now-vacant index

            set._values[index] = last;
            set._indexes[last] = index + 1;

            // clear last index

            set._values.pop();
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC1155 enumerable and aggregate function interface
 */
interface IERC1155Enumerable {
    /**
     * @notice query total minted supply of given token
     * @param id token id to query
     * @return token supply
     */
    function totalSupply(uint256 id) external view returns (uint256);

    /**
     * @notice query total number of holders for given token
     * @param id token id to query
     * @return quantity of holders
     */
    function totalHolders(uint256 id) external view returns (uint256);

    /**
     * @notice query holders of given token
     * @param id token id to query
     * @return list of holder addresses
     */
    function accountsByToken(uint256 id)
        external
        view
        returns (address[] memory);

    /**
     * @notice query tokens held by given address
     * @param account address to query
     * @return list of token ids
     */
    function tokensByAccount(address account)
        external
        view
        returns (uint256[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../../utils/EnumerableSet.sol';
import { ERC1155BaseInternal, ERC1155BaseStorage } from '../base/ERC1155BaseInternal.sol';
import { ERC1155EnumerableStorage } from './ERC1155EnumerableStorage.sol';

/**
 * @title ERC1155Enumerable internal functions
 */
abstract contract ERC1155EnumerableInternal is ERC1155BaseInternal {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;

    /**
     * @notice ERC1155 hook: update aggregate values
     * @inheritdoc ERC1155BaseInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from != to) {
            ERC1155EnumerableStorage.Layout storage l = ERC1155EnumerableStorage
                .layout();
            mapping(uint256 => EnumerableSet.AddressSet)
                storage tokenAccounts = l.accountsByToken;
            EnumerableSet.UintSet storage fromTokens = l.tokensByAccount[from];
            EnumerableSet.UintSet storage toTokens = l.tokensByAccount[to];

            for (uint256 i; i < ids.length; i++) {
                uint256 amount = amounts[i];

                if (amount > 0) {
                    uint256 id = ids[i];

                    if (from == address(0)) {
                        l.totalSupply[id] += amount;
                    } else if (_balanceOf(from, id) == amount) {
                        tokenAccounts[id].remove(from);
                        fromTokens.remove(id);
                    }

                    if (to == address(0)) {
                        l.totalSupply[id] -= amount;
                    } else if (_balanceOf(to, id) == 0) {
                        tokenAccounts[id].add(to);
                        toTokens.add(id);
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { EnumerableSet } from '../../../utils/EnumerableSet.sol';

library ERC1155EnumerableStorage {
    struct Layout {
        mapping(uint256 => uint256) totalSupply;
        mapping(uint256 => EnumerableSet.AddressSet) accountsByToken;
        mapping(address => EnumerableSet.UintSet) tokensByAccount;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Enumerable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library UintUtils {
    function toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0';
        }

        uint256 temp = value;
        uint256 digits;

        while (temp != 0) {
            digits++;
            temp /= 10;
        }

        bytes memory buffer = new bytes(digits);

        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }

        return string(buffer);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title ERC1155Metadata interface
 */
interface IERC1155Metadata {
    /**
     * @notice get generated URI for given token
     * @return token URI
     */
    function uri(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC1155MetadataInternal } from './IERC1155MetadataInternal.sol';
import { ERC1155MetadataStorage } from './ERC1155MetadataStorage.sol';

/**
 * @notice ERC1155Metadata internal functions
 */
abstract contract ERC1155MetadataInternal is IERC1155MetadataInternal {
    /**
     * @notice set base metadata URI
     * @dev base URI is a non-standard feature adapted from the ERC721 specification
     * @param baseURI base URI
     */
    function _setBaseURI(string memory baseURI) internal {
        ERC1155MetadataStorage.layout().baseURI = baseURI;
    }

    /**
     * @notice set per-token metadata URI
     * @param tokenId token whose metadata URI to set
     * @param tokenURI per-token URI
     */
    function _setTokenURI(uint256 tokenId, string memory tokenURI) internal {
        ERC1155MetadataStorage.layout().tokenURIs[tokenId] = tokenURI;
        emit URI(tokenURI, tokenId);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @notice ERC1155 metadata extensions
 */
library ERC1155MetadataStorage {
    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Metadata');

    struct Layout {
        string baseURI;
        mapping(uint256 => string) tokenURIs;
    }

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Partial ERC1155Metadata interface needed by internal functions
 */
interface IERC1155MetadataInternal {
    event URI(string value, uint256 indexed tokenId);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.15;

//
import '@openzeppelin/contracts/utils/Counters.sol';

library LibDropStorage {
  bytes32 public constant STORAGE_SLOT = keccak256('drop.app.storage');
  // Deprecated
  struct DropV1 {
    uint256 timeStart;
    uint256 timeEnd;
    uint256 priceStart;
    uint256 priceEnd;
    uint256 stepDuration;
    uint256 amountCap;
    uint256 shareCyber;
    address payable creator;
    Counters.Counter minted;
    mapping(address => Counters.Counter) mintCounter;
  }

  struct Layout {
    mapping(uint256 => DropV1) dropsV1; // Deprecated
    mapping(uint256 => Drop) drops;
  }

  function layout() internal pure returns (Layout storage lay) {
    bytes32 slot = STORAGE_SLOT;
    assembly {
      lay.slot := slot
    }
  }

  struct Drop {
    uint256 timeStart;
    uint256 timeEnd;
    uint256 price;
    uint256 amountCap;
    uint256 shareCyber;
    address payable creator;
    uint256 minted;
    mapping(address => Counters.Counter) mintCounter;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import '@openzeppelin/contracts/utils/Counters.sol';

import './libraries/LibAppStorage.sol';
import './libraries/LibDropStorage.sol';
import './CyberTokenBase.sol';

contract CyberDropBase is CyberTokenBase {
  using ECDSA for bytes32;
  using Counters for Counters.Counter;

  event DropCreated(address indexed account, uint256 indexed tokenId);

  function dropMintCounter(uint256 _tokenId, address _minter) external view returns (uint256) {
    LibDropStorage.Drop storage drop = LibDropStorage.layout().drops[_tokenId];
    require(drop.amountCap != 0, 'DNE');
    return drop.mintCounter[_minter].current();
  }

  function getDrop(uint256 _tokenId)
    external
    view
    returns (
      uint256 timeStart,
      uint256 timeEnd,
      uint256 price,
      uint256 amountCap,
      uint256 shareCyber,
      address creator,
      uint256 minted
    )
  {
    LibDropStorage.Drop storage drop = LibDropStorage.layout().drops[_tokenId];
    require(drop.amountCap != 0, 'DNE');
    return (drop.timeStart, drop.timeEnd, drop.price, drop.amountCap, drop.shareCyber, drop.creator, drop.minted);
  }

  function createDrop(
    string memory _uri,
    uint256 _timeStart,
    uint256 _timeEnd,
    uint256 _price,
    uint256 _amountCap,
    uint256 _shareCyber,
    bytes memory _signature
  ) external returns (uint256 tokenId) {
    require(_timeEnd - _timeStart > 0, 'IT');
    require(_shareCyber <= 100, 'ISO');
    require(_amountCap > 0, 'IAC');

    LibAppStorage.Layout storage layout = LibAppStorage.layout();
    address sender = _msgSender();
    uint256 nonce = minterNonce(sender);
    bytes memory _message = abi.encodePacked(
      _uri,
      _timeStart,
      _timeEnd,
      _price,
      _amountCap,
      _shareCyber,
      sender,
      nonce
    );
    address recoveredAddress = keccak256(_message).toEthSignedMessageHash().recover(_signature);
    require(recoveredAddress == layout.manager, 'NM');
    tokenId = layout.totalSupply.current();

    // Effects
    setTokenURI(tokenId, _uri);
    layout.totalSupply.increment();
    layout.minterNonce[sender].increment();

    LibDropStorage.Drop storage drop = LibDropStorage.layout().drops[tokenId];
    drop.timeStart = _timeStart;
    drop.timeEnd = _timeEnd;
    drop.price = _price;
    drop.amountCap = _amountCap;
    drop.shareCyber = _shareCyber;
    drop.creator = payable(sender);

    emit DropCreated(sender, tokenId);
  }

  function mint(
    uint256 _tokenId,
    uint256 _quantity,
    bytes memory _signature
  ) external payable returns (bool success) {
    address sender = _msgSender();
    LibDropStorage.Drop storage drop = LibDropStorage.layout().drops[_tokenId];

    require(drop.amountCap - drop.minted >= _quantity, 'CR');

    require(block.timestamp > drop.timeStart && block.timestamp <= drop.timeEnd, 'OOT');

    require(msg.value == drop.price * _quantity, 'IA');

    uint256 senderDropNonce = drop.mintCounter[sender].current();
    bytes memory _message = abi.encodePacked(_tokenId, _quantity, sender, senderDropNonce);
    LibAppStorage.Layout storage layout = LibAppStorage.layout();
    address recoveredAddress = keccak256(_message).toEthSignedMessageHash().recover(_signature);
    require(recoveredAddress == layout.manager, 'NM');

    // Effects
    drop.minted += _quantity;
    drop.mintCounter[sender].increment();
    _safeMint(sender, _tokenId, _quantity, '');

    if (drop.price > 0) {
      uint256 amountOnCyber = (msg.value * drop.shareCyber) / 100;
      uint256 amountCreator = msg.value - amountOnCyber;

      drop.creator.transfer(amountCreator);
      payable(layout.oncyber).transfer(amountOnCyber);
    }

    emit Minted(sender, _tokenId, _quantity);

    return true;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '../../CyberDropBase.sol';

contract OnCyberAndFriendsFactoryFacet is CyberDropBase {}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '../../CyberDropBase.sol';

contract OMFactoryFacet is CyberDropBase {}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '../../CyberDropBase.sol';

contract CyberObjectFactoryFacet is CyberDropBase {}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '../../CyberDropBase.sol';

contract CyberDestinationFactoryFacet is CyberDropBase {}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

//
import '../../CyberDropBase.sol';

contract OnCyberCommunityFactoryFacet is CyberDropBase {}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;
import '@solidstate/contracts/token/ERC1155/IERC1155.sol';

//

contract OnCyberMultiSender {
  function transfer(
    IERC1155 _token,
    uint256 id,
    address[] calldata _receivers,
    uint256[] calldata _quantities
  ) external {
    require(_receivers.length == _quantities.length, 'OnCyberMultiSender: receivers and quantities length mismatch');
    for (uint256 i = 0; i < _receivers.length; i++) {
      _token.safeTransferFrom(msg.sender, _receivers[i], id, _quantities[i], '');
    }
  }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {
    "": {
      "__CACHE_BREAKER__": "0x00000000d41867734bbee4c6863d9255b2b06ac1"
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"DropCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"accountsByToken","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"bool","name":"isLux","type":"bool"}],"name":"burnTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"},{"internalType":"uint256","name":"_timeStart","type":"uint256"},{"internalType":"uint256","name":"_timeEnd","type":"uint256"},{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"uint256","name":"_amountCap","type":"uint256"},{"internalType":"uint256","name":"_shareCyber","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"createDrop","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"address","name":"_minter","type":"address"}],"name":"dropMintCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getDrop","outputs":[{"internalType":"uint256","name":"timeStart","type":"uint256"},{"internalType":"uint256","name":"timeEnd","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"amountCap","type":"uint256"},{"internalType":"uint256","name":"shareCyber","type":"uint256"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"uint256","name":"minted","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"},{"internalType":"address","name":"_manager","type":"address"},{"internalType":"address","name":"_trustedForwarder","type":"address"},{"internalType":"address","name":"_opensea","type":"address"},{"internalType":"address","name":"_oncyber","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"mint","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"name":"minterNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oncyber","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"tokensByAccount","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"updateTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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