APE Price: $0.44 (-1.64%)
    /

    Contract

    0x2Af84138f6DeEE4a601645dD0fDD2f4C88D0CA5f

    Overview

    APE Balance

    Apechain LogoApechain LogoApechain Logo0 APE

    APE Value

    $0.00

    Multichain Info

    No addresses found
    Transaction Hash
    Method
    Block
    Age
    From
    To
    Deploy1155Drop65247482024-12-11 11:13:52115 days ago1733915632IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135054525.42069
    Deploy1155Drop62387682024-12-05 18:21:01120 days ago1733422861IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135057825.42069
    Deploy1155Drop58034502024-11-29 14:25:52127 days ago1732890352IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135072825.42069
    Deploy1155Drop58034412024-11-29 14:25:48127 days ago1732890348IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135072825.42069
    Deploy1155Drop50084112024-11-22 15:38:58134 days ago1732289938IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135119125.42069
    Deploy1155Drop50059442024-11-22 15:22:36134 days ago1732288956IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135054525.42069
    Deploy1155Drop50054382024-11-22 15:18:58134 days ago1732288738IN
    0x2Af84138...C88D0CA5f
    0 APE0.0129977225.42069
    Deploy1155Drop50029542024-11-22 15:01:13134 days ago1732287673IN
    0x2Af84138...C88D0CA5f
    0 APE0.0129974225.42069
    Deploy1155Drop45268592024-11-17 21:17:22138 days ago1731878242IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135063425.42069
    Deploy1155Drop42700992024-11-14 13:22:44142 days ago1731590564IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135106925.42069
    Deploy1155Drop41912572024-11-13 3:26:33143 days ago1731468393IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135063925.42069
    Deploy1155Drop40927422024-11-11 19:00:37144 days ago1731351637IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135097725.42069
    Deploy1155Drop40603252024-11-11 11:00:55145 days ago1731322855IN
    0x2Af84138...C88D0CA5f
    0 APE0.0130032925.42069
    Deploy1155Drop38651112024-11-08 17:10:56148 days ago1731085856IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135094425.42069
    Deploy1155Drop37876172024-11-07 22:06:51148 days ago1731017211IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135109925.42069
    Deploy1155Drop37355022024-11-07 8:16:00149 days ago1730967360IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135051425.42069
    Deploy1155Drop37345712024-11-07 7:54:15149 days ago1730966055IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135088525.42069
    Deploy1155Drop37345442024-11-07 7:53:33149 days ago1730966013IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135088525.42069
    Deploy1155Drop34496492024-11-04 13:30:31152 days ago1730727031IN
    0x2Af84138...C88D0CA5f
    0 APE0.0155504225.42069
    Deploy1155Drop34496442024-11-04 13:30:28152 days ago1730727028IN
    0x2Af84138...C88D0CA5f
    0 APE0.0155503925.42069
    Deploy1155Drop34487092024-11-04 13:18:27152 days ago1730726307IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135045125.42069
    Deploy1155Drop34484322024-11-04 13:14:15152 days ago1730726055IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135045125.42069
    Deploy1155Drop33066592024-11-03 9:28:46153 days ago1730626126IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135054525.42069
    Deploy1155Drop30274642024-11-01 0:49:49155 days ago1730422189IN
    0x2Af84138...C88D0CA5f
    0 APE0.0135103825.42069
    Deploy1155Drop28890052024-10-30 23:10:48156 days ago1730329848IN
    0x2Af84138...C88D0CA5f
    0 APE0.0130029325.42069
    View all transactions

    Latest 25 internal transactions (View All)

    Parent Transaction Hash Block Age From To Amount
    65247482024-12-11 11:13:52115 days ago1733915632
    0x2Af84138...C88D0CA5f
    0 APE
    62387682024-12-05 18:21:01120 days ago1733422861
    0x2Af84138...C88D0CA5f
    0 APE
    58034502024-11-29 14:25:52127 days ago1732890352
    0x2Af84138...C88D0CA5f
    0 APE
    58034412024-11-29 14:25:48127 days ago1732890348
    0x2Af84138...C88D0CA5f
    0 APE
    50084112024-11-22 15:38:58134 days ago1732289938
    0x2Af84138...C88D0CA5f
    0 APE
    50059442024-11-22 15:22:36134 days ago1732288956
    0x2Af84138...C88D0CA5f
    0 APE
    50054382024-11-22 15:18:58134 days ago1732288738
    0x2Af84138...C88D0CA5f
    0 APE
    50029542024-11-22 15:01:13134 days ago1732287673
    0x2Af84138...C88D0CA5f
    0 APE
    45268592024-11-17 21:17:22138 days ago1731878242
    0x2Af84138...C88D0CA5f
    0 APE
    42700992024-11-14 13:22:44142 days ago1731590564
    0x2Af84138...C88D0CA5f
    0 APE
    41912572024-11-13 3:26:33143 days ago1731468393
    0x2Af84138...C88D0CA5f
    0 APE
    40927422024-11-11 19:00:37144 days ago1731351637
    0x2Af84138...C88D0CA5f
    0 APE
    40603252024-11-11 11:00:55145 days ago1731322855
    0x2Af84138...C88D0CA5f
    0 APE
    38651112024-11-08 17:10:56148 days ago1731085856
    0x2Af84138...C88D0CA5f
    0 APE
    37876172024-11-07 22:06:51148 days ago1731017211
    0x2Af84138...C88D0CA5f
    0 APE
    37355022024-11-07 8:16:00149 days ago1730967360
    0x2Af84138...C88D0CA5f
    0 APE
    37345712024-11-07 7:54:15149 days ago1730966055
    0x2Af84138...C88D0CA5f
    0 APE
    37345442024-11-07 7:53:33149 days ago1730966013
    0x2Af84138...C88D0CA5f
    0 APE
    34496492024-11-04 13:30:31152 days ago1730727031
    0x2Af84138...C88D0CA5f
    0 APE
    34496442024-11-04 13:30:28152 days ago1730727028
    0x2Af84138...C88D0CA5f
    0 APE
    34487092024-11-04 13:18:27152 days ago1730726307
    0x2Af84138...C88D0CA5f
    0 APE
    34484322024-11-04 13:14:15152 days ago1730726055
    0x2Af84138...C88D0CA5f
    0 APE
    33066592024-11-03 9:28:46153 days ago1730626126
    0x2Af84138...C88D0CA5f
    0 APE
    30274642024-11-01 0:49:49155 days ago1730422189
    0x2Af84138...C88D0CA5f
    0 APE
    28890052024-10-30 23:10:48156 days ago1730329848
    0x2Af84138...C88D0CA5f
    0 APE
    View All Internal Transactions

    Loading...
    Loading

    Contract Source Code Verified (Exact Match)

    Contract Name:
    PufflesERC1155Deployer

    Compiler Version
    v0.8.26+commit.8a97fa7a

    Optimization Enabled:
    Yes with 200 runs

    Other Settings:
    default evmVersion
    File 1 of 28 : PufflesERC1155Deployer.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.17;
    import "@openzeppelin/contracts/proxy/Clones.sol";
    import "@openzeppelin/contracts/access/AccessControl.sol";
    import "./PufflesERC1155.sol";
    contract PufflesERC1155Deployer is AccessControl {
    address private DEFAULT_OPERATOR_FILTER =
    address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
    address private drop721Implementation;
    address private drop1155Implementation;
    event ContractCreated(address creator, address contractAddress);
    constructor() {
    _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
    }
    function updateDefaultOperatorFilter(
    address newFilter
    ) external onlyRole(DEFAULT_ADMIN_ROLE) {
    DEFAULT_OPERATOR_FILTER = newFilter;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 2 of 28 : PufflesERC1155.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.17;
    import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";
    import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
    import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
    import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
    import "@openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol";
    import "operator-filter-registry/src/upgradeable/OperatorFiltererUpgradeable.sol";
    import "./ICommon.sol";
    struct TokenSettings {
    /// @dev total number of tokens that can be minted
    uint32 maxSupply;
    /// @dev total number of tokens that can be minted per wallet
    uint32 maxPerWallet;
    /// @dev tracks the total amount that have been minted
    uint32 amountMinted;
    /// @dev merkle root associated with claiming the token, otherwise bytes32(0)
    bytes32 merkleRoot;
    /// @dev timestamp of when the token can be minted
    uint32 mintStart;
    /// @dev timestamp of when the token can no longer be minted
    uint32 mintEnd;
    /// @dev price for the phase
    uint256 price;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 3 of 28 : AccessControl.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)
    pragma solidity ^0.8.20;
    import {IAccessControl} from "./IAccessControl.sol";
    import {Context} from "../utils/Context.sol";
    import {ERC165} from "../utils/introspection/ERC165.sol";
    /**
    * @dev Contract module that allows children to implement role-based access
    * control mechanisms. This is a lightweight version that doesn't allow enumerating role
    * members except through off-chain means by accessing the contract event logs. Some
    * applications may benefit from on-chain enumerability, for those cases see
    * {AccessControlEnumerable}.
    *
    * Roles are referred to by their `bytes32` identifier. These should be exposed
    * in the external API and be unique. The best way to achieve this is by
    * using `public constant` hash digests:
    *
    * ```solidity
    * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
    * ```
    *
    * Roles can be used to represent a set of permissions. To restrict access to a
    * function call, use {hasRole}:
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 4 of 28 : Clones.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (proxy/Clones.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
    * deploying minimal proxy contracts, also known as "clones".
    *
    * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
    * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
    *
    * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
    * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
    * deterministic method.
    */
    library Clones {
    /**
    * @dev A clone instance deployment failed.
    */
    error ERC1167FailedCreateClone();
    /**
    * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
    *
    * This function uses the create opcode, which should never revert.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 5 of 28 : ICommon.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.17;
    error InvalidPrice();
    error SoldOut();
    error ExceedMaxPerWallet();
    error InvalidProof();
    error InvalidMintFunction();
    error InvalidAirdrop();
    error BurningNotAllowed();
    struct PaymentSplitterSettings {
    address[] payees;
    uint256[] shares;
    }
    struct RoyaltySettings {
    address royaltyAddress;
    uint96 royaltyAmount;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 6 of 28 : OperatorFiltererUpgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.13;
    import {IOperatorFilterRegistry} from "../IOperatorFilterRegistry.sol";
    import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
    /**
    * @title OperatorFiltererUpgradeable
    * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
    * registrant's entries in the OperatorFilterRegistry when the init function is called.
    * @dev This smart contract is meant to be inherited by token contracts so they can use the following:
    * - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
    * - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
    */
    abstract contract OperatorFiltererUpgradeable is Initializable {
    /// @notice Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);
    IOperatorFilterRegistry constant OPERATOR_FILTER_REGISTRY =
    IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
    /// @dev The upgradeable initialize function that should be called when the contract is being upgraded.
    function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe)
    internal
    onlyInitializing
    {
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 7 of 28 : ERC2981Upgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (token/common/ERC2981.sol)
    pragma solidity ^0.8.20;
    import {IERC2981} from "@openzeppelin/contracts/interfaces/IERC2981.sol";
    import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
    import {ERC165Upgradeable} from "../../utils/introspection/ERC165Upgradeable.sol";
    import {Initializable} from "../../proxy/utils/Initializable.sol";
    /**
    * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
    *
    * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
    * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
    *
    * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
    * fee is specified in basis points by default.
    *
    * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
    * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
    * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
    */
    abstract contract ERC2981Upgradeable is Initializable, IERC2981, ERC165Upgradeable {
    struct RoyaltyInfo {
    address receiver;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 8 of 28 : AddressUpgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
    pragma solidity ^0.8.1;
    /**
    * @dev Collection of functions related to the address type
    */
    library AddressUpgradeable {
    /**
    * @dev Returns true if `account` is a contract.
    *
    * [IMPORTANT]
    * ====
    * It is unsafe to assume that an address for which this function returns
    * false is an externally-owned account (EOA) and not a contract.
    *
    * Among others, `isContract` will return false for the following
    * types of addresses:
    *
    * - an externally-owned account
    * - a contract in construction
    * - an address where a contract will be created
    * - an address where a contract lived, but was destroyed
    *
    * Furthermore, `isContract` will also return true if the target contract within
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 9 of 28 : MerkleProof.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)
    pragma solidity ^0.8.0;
    /**
    * @dev These functions deal with verification of Merkle Tree proofs.
    *
    * The tree and the proofs can be generated using our
    * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
    * You will find a quickstart guide in the readme.
    *
    * WARNING: You should avoid using leaf values that are 64 bytes long prior to
    * hashing, or use a hash function other than keccak256 for hashing leaves.
    * This is because the concatenation of a sorted pair of internal nodes in
    * the Merkle tree could be reinterpreted as a leaf value.
    * OpenZeppelin's JavaScript library generates Merkle trees that are safe
    * against this attack out of the box.
    */
    library MerkleProof {
    /**
    *@dev The multiproof provided is not valid.
    */
    error MerkleProofInvalidMultiproof();
    /**
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 10 of 28 : OwnableUpgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
    pragma solidity ^0.8.0;
    import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
    import {Initializable} from "../proxy/utils/Initializable.sol";
    /**
    * @dev Contract module which provides a basic access control mechanism, where
    * there is an account (an owner) that can be granted exclusive access to
    * specific functions.
    *
    * The initial owner is set to the address provided by the deployer. This can
    * later be changed with {transferOwnership}.
    *
    * This module is used through inheritance. It will make available the modifier
    * `onlyOwner`, which can be applied to your functions to restrict their use to
    * the owner.
    */
    abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Ownable
    struct OwnableStorage {
    address _owner;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 11 of 28 : ERC1155SupplyUpgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/ERC1155Supply.sol)
    pragma solidity ^0.8.20;
    import {ERC1155Upgradeable} from "../ERC1155Upgradeable.sol";
    import {Initializable} from "../../../proxy/utils/Initializable.sol";
    /**
    * @dev Extension of ERC1155 that adds tracking of total supply per id.
    *
    * Useful for scenarios where Fungible and Non-fungible tokens have to be
    * clearly identified. Note: While a totalSupply of 1 might mean the
    * corresponding is an NFT, there is no guarantees that no other token with the
    * same id are not going to be minted.
    *
    * NOTE: This contract implies a global limit of 2**256 - 1 to the number of tokens
    * that can be minted.
    *
    * CAUTION: This extension should not be added in an upgrade to an already deployed contract.
    */
    abstract contract ERC1155SupplyUpgradeable is Initializable, ERC1155Upgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC1155Supply
    struct ERC1155SupplyStorage {
    mapping(uint256 id => uint256) _totalSupply;
    uint256 _totalSupplyAll;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 12 of 28 : ERC165.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)
    pragma solidity ^0.8.20;
    import {IERC165} from "./IERC165.sol";
    /**
    * @dev Implementation of the {IERC165} interface.
    *
    * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
    * for the additional interface id that will be supported. For example:
    *
    * ```solidity
    * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
    * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
    * }
    * ```
    */
    abstract contract ERC165 is IERC165 {
    /**
    * @dev See {IERC165-supportsInterface}.
    */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
    return interfaceId == type(IERC165).interfaceId;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 13 of 28 : Context.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Provides information about the current execution context, including the
    * sender of the transaction and its data. While these are generally available
    * via msg.sender and msg.data, they should not be accessed in such a direct
    * manner, since when dealing with meta-transactions the account sending and
    * paying for execution may not be the actual sender (as far as an application
    * is concerned).
    *
    * This contract is only required for intermediate, library-like contracts.
    */
    abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
    return msg.sender;
    }
    function _msgData() internal view virtual returns (bytes calldata) {
    return msg.data;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 14 of 28 : IAccessControl.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev External interface of AccessControl declared to support ERC165 detection.
    */
    interface IAccessControl {
    /**
    * @dev The `account` is missing a role.
    */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
    /**
    * @dev The caller of a function is not the expected one.
    *
    * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
    */
    error AccessControlBadConfirmation();
    /**
    * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
    *
    * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
    * {RoleAdminChanged} not being emitted signaling this.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 15 of 28 : Initializable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
    pragma solidity ^0.8.0;
    /**
    * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
    * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
    * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
    * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
    *
    * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
    * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
    * case an upgrade adds a module that needs to be initialized.
    *
    * For example:
    *
    * [.hljs-theme-light.nopadding]
    * ```solidity
    * contract MyToken is ERC20Upgradeable {
    * function initialize() initializer public {
    * __ERC20_init("MyToken", "MTK");
    * }
    * }
    *
    * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 16 of 28 : IOperatorFilterRegistry.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.13;
    interface IOperatorFilterRegistry {
    /**
    * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
    * true if supplied registrant address is not registered.
    */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    /**
    * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
    */
    function register(address registrant) external;
    /**
    * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
    */
    function registerAndSubscribe(address registrant, address subscription) external;
    /**
    * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
    * address without subscribing.
    */
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 17 of 28 : IERC165.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Interface of the ERC165 standard, as defined in the
    * https://eips.ethereum.org/EIPS/eip-165[EIP].
    *
    * Implementers can declare support of contract interfaces, which can then be
    * queried by others ({ERC165Checker}).
    *
    * For an implementation, see {ERC165}.
    */
    interface IERC165 {
    /**
    * @dev Returns true if this contract implements the interface defined by
    * `interfaceId`. See the corresponding
    * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
    * to learn more about how these ids are created.
    *
    * This function call must use less than 30 000 gas.
    */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 18 of 28 : ERC165Upgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)
    pragma solidity ^0.8.20;
    import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
    import {Initializable} from "../../proxy/utils/Initializable.sol";
    /**
    * @dev Implementation of the {IERC165} interface.
    *
    * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
    * for the additional interface id that will be supported. For example:
    *
    * ```solidity
    * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
    * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
    * }
    * ```
    */
    abstract contract ERC165Upgradeable is Initializable, IERC165 {
    function __ERC165_init() internal onlyInitializing {
    }
    function __ERC165_init_unchained() internal onlyInitializing {
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 19 of 28 : IERC2981.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC2981.sol)
    pragma solidity ^0.8.20;
    import {IERC165} from "../utils/introspection/IERC165.sol";
    /**
    * @dev Interface for the NFT Royalty Standard.
    *
    * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
    * support for royalty payments across all NFT marketplaces and ecosystem participants.
    */
    interface IERC2981 is IERC165 {
    /**
    * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
    * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
    */
    function royaltyInfo(
    uint256 tokenId,
    uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 20 of 28 : ERC1155Upgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/ERC1155.sol)
    pragma solidity ^0.8.20;
    import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
    import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
    import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
    import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
    import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
    import {ERC165Upgradeable} from "../../utils/introspection/ERC165Upgradeable.sol";
    import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol";
    import {IERC1155Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
    import {Initializable} from "../../proxy/utils/Initializable.sol";
    /**
    * @dev Implementation of the basic standard multi-token.
    * See https://eips.ethereum.org/EIPS/eip-1155
    * Originally based on code by Enjin: https://github.com/enjin/erc-1155
    */
    abstract contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155, IERC1155MetadataURI, IERC1155Errors {
    using Arrays for uint256[];
    using Arrays for address[];
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC1155
    struct ERC1155Storage {
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 21 of 28 : ContextUpgradeable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)
    pragma solidity ^0.8.0;
    import {Initializable} from "../proxy/utils/Initializable.sol";
    /**
    * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }
    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
    return msg.sender;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 22 of 28 : draft-IERC6093.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Standard ERC20 Errors
    * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
    */
    interface IERC20Errors {
    /**
    * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    * @param sender Address whose tokens are being transferred.
    * @param balance Current balance for the interacting account.
    * @param needed Minimum amount required to perform a transfer.
    */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    /**
    * @dev Indicates a failure with the token `sender`. Used in transfers.
    * @param sender Address whose tokens are being transferred.
    */
    error ERC20InvalidSender(address sender);
    /**
    * @dev Indicates a failure with the token `receiver`. Used in transfers.
    * @param receiver Address to which tokens are being transferred.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 23 of 28 : Arrays.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol)
    pragma solidity ^0.8.20;
    import {StorageSlot} from "./StorageSlot.sol";
    import {Math} from "./math/Math.sol";
    /**
    * @dev Collection of functions related to array types.
    */
    library Arrays {
    using StorageSlot for bytes32;
    /**
    * @dev Searches a sorted `array` and returns the first index that contains
    * a value greater or equal to `element`. If no such index exists (i.e. all
    * values in the array are strictly less than `element`), the array length is
    * returned. Time complexity O(log n).
    *
    * `array` is expected to be sorted in ascending order, and to contain no
    * repeated elements.
    */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
    uint256 low = 0;
    uint256 high = array.length;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 24 of 28 : IERC1155MetadataURI.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)
    pragma solidity ^0.8.20;
    import {IERC1155} from "../IERC1155.sol";
    /**
    * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
    * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
    */
    interface IERC1155MetadataURI is IERC1155 {
    /**
    * @dev Returns the URI for token type `id`.
    *
    * If the `\{id\}` substring is present in the URI, it must be replaced by
    * clients with the actual token type ID.
    */
    function uri(uint256 id) external view returns (string memory);
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 25 of 28 : IERC1155Receiver.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)
    pragma solidity ^0.8.20;
    import {IERC165} from "../../utils/introspection/IERC165.sol";
    /**
    * @dev Interface that must be implemented by smart contracts in order to receive
    * ERC-1155 token transfers.
    */
    interface IERC1155Receiver is IERC165 {
    /**
    * @dev Handles the receipt of a single ERC1155 token type. This function is
    * called at the end of a `safeTransferFrom` after the balance has been updated.
    *
    * NOTE: To accept the transfer, this must return
    * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
    * (i.e. 0xf23a6e61, or its own function selector).
    *
    * @param operator The address which initiated the transfer (i.e. msg.sender)
    * @param from The address which previously owned the token
    * @param id The ID of the token being transferred
    * @param value The amount of tokens being transferred
    * @param data Additional data with no specified format
    * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 26 of 28 : IERC1155.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)
    pragma solidity ^0.8.20;
    import {IERC165} from "../../utils/introspection/IERC165.sol";
    /**
    * @dev Required interface of an ERC1155 compliant contract, as defined in the
    * https://eips.ethereum.org/EIPS/eip-1155[EIP].
    */
    interface IERC1155 is IERC165 {
    /**
    * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
    */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
    /**
    * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
    * transfers.
    */
    event TransferBatch(
    address indexed operator,
    address indexed from,
    address indexed to,
    uint256[] ids,
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 27 of 28 : Math.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Standard math utilities missing in the Solidity language.
    */
    library Math {
    /**
    * @dev Muldiv operation overflow.
    */
    error MathOverflowedMulDiv();
    enum Rounding {
    Floor, // Toward negative infinity
    Ceil, // Toward positive infinity
    Trunc, // Toward zero
    Expand // Away from zero
    }
    /**
    * @dev Returns the addition of two unsigned integers, with an overflow flag.
    */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
    unchecked {
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 28 of 28 : StorageSlot.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
    // This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
    pragma solidity ^0.8.20;
    /**
    * @dev Library for reading and writing primitive types to specific storage slots.
    *
    * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
    * This library helps with reading and writing to such slots without the need for inline assembly.
    *
    * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
    *
    * Example usage to set ERC1967 implementation slot:
    * ```solidity
    * contract ERC1967 {
    * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    *
    * function _getImplementation() internal view returns (address) {
    * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    * }
    *
    * function _setImplementation(address newImplementation) internal {
    * require(newImplementation.code.length > 0);
    * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Settings
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    {
    "optimizer": {
    "enabled": true,
    "runs": 200
    },
    "outputSelection": {
    "*": {
    "*": [
    "evm.bytecode",
    "evm.deployedBytecode",
    "devdoc",
    "userdoc",
    "metadata",
    "abi"
    ]
    }
    },
    "remappings": []
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Contract Security Audit

    Contract ABI

    API
    [{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ERC1167FailedCreateClone","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"creator","type":"address"},{"indexed":false,"internalType":"address","name":"contractAddress","type":"address"}],"name":"ContractCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_baseUri","type":"string"},{"components":[{"internalType":"uint32","name":"maxSupply","type":"uint32"},{"internalType":"uint32","name":"maxPerWallet","type":"uint32"},{"internalType":"uint32","name":"amountMinted","type":"uint32"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint32","name":"mintStart","type":"uint32"},{"internalType":"uint32","name":"mintEnd","type":"uint32"},{"internalType":"uint256","name":"price","type":"uint256"},{"components":[{"internalType":"address[]","name":"payees","type":"address[]"},{"internalType":"uint256[]","name":"shares","type":"uint256[]"}],"internalType":"struct PaymentSplitterSettings","name":"paymentSplitterSettings","type":"tuple"}],"internalType":"struct TokenSettings[]","name":"_tokenSettings","type":"tuple[]"},{"components":[{"internalType":"address","name":"royaltyAddress","type":"address"},{"internalType":"uint96","name":"royaltyAmount","type":"uint96"}],"internalType":"struct RoyaltySettings","name":"_royaltySettings","type":"tuple"},{"components":[{"internalType":"address[]","name":"payees","type":"address[]"},{"internalType":"uint256[]","name":"shares","type":"uint256[]"}],"internalType":"struct PaymentSplitterSettings","name":"_paymentSplitterSettings","type":"tuple"},{"internalType":"bool","name":"_registerOperatorFilter","type":"bool"},{"internalType":"bool","name":"_allowBurning","type":"bool"}],"name":"deploy1155Drop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOperatorFilter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","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":"newImplementation","type":"address"}],"name":"update1155Implementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newFilter","type":"address"}],"name":"updateDefaultOperatorFilter","outputs":[],"stateMutability":"nonpayable","type":"function"}]

    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

    Deployed Bytecode

    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

    Block Age Transaction Difficulty Gas Used Reward
    View All Blocks Produced

    Block Age Uncle Number Difficulty Gas Used Reward
    View All Uncles
    Loading...
    Loading
    Loading...
    Loading

    Validator Index Block Age Amount
    View All Withdrawals

    Transaction Hash Block Age Value Eth2 PubKey Valid
    View All Deposits
    [ Download: CSV Export  ]
    [ Download: CSV Export  ]

    A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.