Contract

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.10;

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

contract CyberDestinationUtilityFactoryFacet is CyberDropBase {}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.10;

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.0 (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.10;

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.10;

//
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 v4.4.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.
            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.
            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;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 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.0 (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 <[email protected]> (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.10;

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.10;

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 v4.4.0 (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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.10;

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

library LibDropStorage {
  bytes32 public constant STORAGE_SLOT = keccak256('drop.app.storage');
  struct Drop {
    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 => Drop) drops;
  }

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

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

//
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)
    public
    view
    returns (uint256)
  {
    LibDropStorage.Drop storage drop = LibDropStorage.layout().drops[_tokenId];
    require(drop.priceStart != 0, 'DNE');
    return drop.mintCounter[_minter].current();
  }

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

    return (
      drop.timeStart,
      drop.timeEnd,
      drop.priceStart,
      drop.priceEnd,
      drop.stepDuration,
      drop.amountCap,
      drop.shareCyber,
      drop.creator,
      drop.minted.current()
    );
  }

  function createDrop(
    string memory _uri,
    uint256 _timeStart,
    uint256 _timeEnd,
    uint256 _priceStart,
    uint256 _priceEnd,
    uint256 _stepDuration,
    uint256 _amountCap,
    uint256 _shareCyber,
    bytes memory _signature
  ) public returns (uint256 tokenId) {
    require(_timeEnd - _timeStart >= _stepDuration && _stepDuration > 0, 'IT');
    require(_priceStart >= _priceEnd && _priceStart > 0, 'IP');
    require(_shareCyber <= 100, 'ISO');

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

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

    LibDropStorage.layout().drops[tokenId].timeStart = _timeStart;
    LibDropStorage.layout().drops[tokenId].timeEnd = _timeEnd;
    LibDropStorage.layout().drops[tokenId].priceStart = _priceStart;
    LibDropStorage.layout().drops[tokenId].priceEnd = _priceEnd;
    LibDropStorage.layout().drops[tokenId].stepDuration = _stepDuration;
    LibDropStorage.layout().drops[tokenId].amountCap = _amountCap;
    LibDropStorage.layout().drops[tokenId].shareCyber = _shareCyber;
    LibDropStorage.layout().drops[tokenId].creator = payable(sender);

    // Mint for creator
    LibDropStorage.layout().drops[tokenId].minted.increment();
    LibDropStorage.layout().drops[tokenId].mintCounter[sender].increment();
    _safeMint(sender, tokenId, 1, '');

    emit DropCreated(sender, tokenId);
    emit Minted(sender, tokenId, 1);
  }

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

    if (drop.amountCap != 0) {
      require(drop.minted.current() < drop.amountCap, 'CR');
    }

    require(
      block.timestamp > drop.timeStart && block.timestamp <= drop.timeEnd,
      'OOT'
    );
    uint256 timeSpent = block.timestamp - drop.timeStart;
    uint256 duration = drop.timeEnd - drop.timeStart;
    uint256 price = getPriceFor(
      timeSpent,
      duration,
      drop.priceStart,
      drop.priceEnd,
      drop.stepDuration
    );
    require(msg.value >= price, 'IA');
    uint256 amountOnCyber = (msg.value * drop.shareCyber) / 100;
    uint256 amountCreator = msg.value - amountOnCyber;

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

    // Effects
    drop.minted.increment();
    drop.mintCounter[sender].increment();
    _safeMint(sender, _tokenId, 1, '');
    drop.creator.transfer(amountCreator);
    payable(LibAppStorage.layout().oncyber).transfer(amountOnCyber);

    emit Minted(sender, _tokenId, 1);

    return true;
  }

  function getMintPriceForToken(uint256 _tokenId)
    public
    view
    returns (uint256 mintPrice)
  {
    LibDropStorage.Drop storage drop = LibDropStorage.layout().drops[_tokenId];
    require(drop.priceStart != 0, 'DNE');

    if (drop.amountCap != 0) {
      require(drop.minted.current() < drop.amountCap, 'CR');
    }

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

    return
      getPriceFor(
        timeSpent,
        duration,
        drop.priceStart,
        drop.priceEnd,
        drop.stepDuration
      );
  }

  function getPriceFor(
    uint256 _timeSpent,
    uint256 _duration,
    uint256 _priceStart,
    uint256 _priceEnd,
    uint256 _stepDuration
  ) public pure returns (uint256 price) {
    // https://www.desmos.com/calculator/oajpdvew5q
    // f\left(x\right)=\frac{s\ \cdot d\ +\ \operatorname{mod}\left(x,\ g\right)\ \cdot\ \left(s\ -\ l\right)\ -\ x\ \cdot\ \left(s\ -\ l\right)\ \ }{d}
    // (s * d + (x % g) * (s - l) - x * (s - l) / d
    return
      (_duration *
        _priceStart +
        (_timeSpent % _stepDuration) *
        (_priceStart - _priceEnd) -
        _timeSpent *
        (_priceStart - _priceEnd)) / _duration;
  }
}

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

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

contract CyberObjectFactoryFacet is CyberDropBase {}

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

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

contract CyberDestinationFactoryFacet is CyberDropBase {}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "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":"string","name":"_uri","type":"string"},{"internalType":"uint256","name":"_timeStart","type":"uint256"},{"internalType":"uint256","name":"_timeEnd","type":"uint256"},{"internalType":"uint256","name":"_priceStart","type":"uint256"},{"internalType":"uint256","name":"_priceEnd","type":"uint256"},{"internalType":"uint256","name":"_stepDuration","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":"priceStart","type":"uint256"},{"internalType":"uint256","name":"priceEnd","type":"uint256"},{"internalType":"uint256","name":"stepDuration","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":"uint256","name":"_tokenId","type":"uint256"}],"name":"getMintPriceForToken","outputs":[{"internalType":"uint256","name":"mintPrice","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_timeSpent","type":"uint256"},{"internalType":"uint256","name":"_duration","type":"uint256"},{"internalType":"uint256","name":"_priceStart","type":"uint256"},{"internalType":"uint256","name":"_priceEnd","type":"uint256"},{"internalType":"uint256","name":"_stepDuration","type":"uint256"}],"name":"getPriceFor","outputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"stateMutability":"pure","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":"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"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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