Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

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.9;
import {ConfigSettings} from "gwei-slim-nft-contracts/contracts/base/ERC721Base.sol";
import {ERC721Delegated} from "gwei-slim-nft-contracts/contracts/base/ERC721Delegated.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Address.sol";
contract DeadPunks is ERC721Delegated, ReentrancyGuard {
  using Counters for Counters.Counter;
  constructor(address baseFactory, string memory customBaseURI_)
    ERC721Delegated(
      baseFactory,
      "DeadPunks",
      "DPNKS",
      ConfigSettings({
        royaltyBps: 500,
        uriBase: customBaseURI_,
        uriExtension: "",
        hasTransferHook: false
      })
    )
  {}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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: GPL-3.0
pragma solidity 0.8.9;
import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {StringsUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import {CountersUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import {IBaseERC721Interface} from "./IBaseERC721Interface.sol";
struct ConfigSettings {
    uint16 royaltyBps;
    string uriBase;
    string uriExtension;
    bool hasTransferHook;
}
/**
    This smart contract adds features and allows for a ownership only by another smart contract as fallback behavior
    while also implementing all normal ERC721 functions as expected
*/
contract ERC721Base is
    ERC721Upgradeable,
    IBaseERC721Interface,
    IERC2981Upgradeable,
    OwnableUpgradeable
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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: GPL-3.0
pragma solidity 0.8.9;
import {StorageSlotUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol";
import {IBaseERC721Interface, ConfigSettings} from "./ERC721Base.sol";
contract ERC721Delegated {
    uint256[100000] gap;
    bytes32 internal constant _IMPLEMENTATION_SLOT =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    // Reference to base NFT implementation
    function implementation() public view returns (address) {
        return
            StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }
    function _initImplementation(address _nftImplementation) private {
        StorageSlotUpgradeable
            .getAddressSlot(_IMPLEMENTATION_SLOT)
            .value = _nftImplementation;
    }
    /// Constructor that sets up the
    constructor(
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.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 {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
import "./IERC721Upgradeable.sol";
import "./IERC721ReceiverUpgradeable.sol";
import "./extensions/IERC721MetadataUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/StringsUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable {
    using AddressUpgradeable for address;
    using StringsUpgradeable for uint256;
    // Token name
    string private _name;
    // Token symbol
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
/**
 * @dev Interface for the NFT Royalty Standard
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Called with the sale price to determine how much royalty is owed and to whom.
     * @param tokenId - the NFT asset queried for royalty information
     * @param salePrice - the sale price of the NFT asset specified by `tokenId`
     * @return receiver - address of who should be sent the royalty payment
     * @return royaltyAmount - the royalty payment amount for `salePrice`
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
import "../utils/ContextUpgradeable.sol";
import "../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.
 *
 * By default, the owner account will be the one that deploys the contract. 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 {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
/**
 * @dev String operations.
 */
library StringsUpgradeable {
    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;
        }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.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 CountersUpgradeable {
    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 {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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: GPL-3.0
pragma solidity 0.8.9;
/// Additional features and functions assigned to the
/// Base721 contract for hooks and overrides
interface IBaseERC721Interface {
    /*
     Exposing common NFT internal functionality for base contract overrides
     To save gas and make API cleaner this is only for new functionality not exposed in
     the core ERC721 contract
    */
    /// Mint an NFT. Allowed to mint by owner, approval or by the parent contract
    /// @param tokenId id to burn
    function __burn(uint256 tokenId) external;
    /// Mint an NFT. Allowed only by the parent contract
    /// @param to address to mint to
    /// @param tokenId token id to mint
    function __mint(address to, uint256 tokenId) external;
    /// Set the base URI of the contract. Allowed only by parent contract
    /// @param base base uri
    /// @param extension extension
    function __setBaseURI(string memory base, string memory extension) external;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
/**
 * @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:
 * ```
 * 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(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721Upgradeable is IERC165Upgradeable {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
    /**
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721ReceiverUpgradeable {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
import "../IERC721Upgradeable.sol";
/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);
    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);
    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
import "../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 initializer {
        __Context_init_unchained();
    }
    function __Context_init_unchained() internal initializer {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.0;
import "./IERC165Upgradeable.sol";
import "../../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);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal initializer {
        __ERC165_init_unchained();
    }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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.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 a proxied contract can't have 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.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;
    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../utils/introspection/IERC165Upgradeable.sol";
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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
pragma solidity ^0.8.0;
/**
 * @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 IERC165Upgradeable {
    /**
     * @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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"baseFactory","type":"address"},{"internalType":"string","name":"customBaseURI_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"MAX_MULTIMINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"customBaseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"saleIsActive_","type":"bool"}],"name":"setSaleIsActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000043955024b1985e2b933a59021500ae5f55b040910000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d51696b70326456345a56676150664771447638643431486e7865427a73563671694e47456a6369474b316b522f00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : baseFactory (address): 0x43955024b1985E2b933A59021500aE5f55b04091
Arg [1] : customBaseURI_ (string): https://ipfs.io/ipfs/QmQikp2dV4ZVgaPfGqDv8d41HnxeBzsV6qiNGEjciGK1kR/

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 00000000000000000000000043955024b1985e2b933a59021500ae5f55b04091
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000044
Arg [3] : 68747470733a2f2f697066732e696f2f697066732f516d51696b70326456345a
Arg [4] : 56676150664771447638643431486e7865427a73563671694e47456a6369474b
Arg [5] : 316b522f00000000000000000000000000000000000000000000000000000000