0xce25e60a89f200b1fa40f6c313047ffe386992c3

deployer: unknown relevance score: 0 status: partially_identified bytecode: 9287 bytes

DECOMPILED SOLIDITY (Heimdall)

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @title            Decompiled Contract
/// @author           Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version   heimdall-rs v0.9.2
///
/// @notice           This contract was decompiled using the heimdall-rs decompiler.
///                     It was generated directly by tracing the EVM opcodes from this contract.
///                     As a result, it may not compile or even be valid solidity code.
///                     Despite this, it should be obvious what each function does. Overall
///                     logic should have been preserved throughout decompiling.
///
/// @custom:github    You can find the open-source decompiler here:
///                       https://heimdall.rs

contract DecompiledContract {
    uint256 public constant NFT_PRICE = 50000000000000000;
    uint256 public constant MAX_NFT_PURCHASE = 5;
    
    uint256 public unresolved_18160ddd;
    bool public saleIsActive;
    address public owner;
    uint256 store_e;
    uint256 public startingIndex;
    uint256 public startingIndexBlock;
    uint256 public MAX_SUPPLY;
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_l;
    bytes32 store_i;
    bytes32 store_j;
    
    event Event_8c5be1e5();
    event Transfer(address, address, uint256);
    event Event_17307eab();
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        uint256 var_a = arg1;
        require(address(storage_map_a[var_a]), "ERC721: owner query for nonexistent token");
        require(!(address(arg0) == (address(storage_map_a[var_a]))), "ERC721: owner query for nonexistent token");
        require(address(storage_map_a[var_a]) == msg.sender, "ERC721: owner query for nonexistent token");
        var_a = address(msg.sender);
        require(bytes1(storage_map_a[var_a]), "ERC721: owner query for nonexistent token");
        var_a = arg1;
        storage_map_a[var_a] = (address(arg0)) | (uint96(storage_map_a[var_a]));
        var_a = arg1;
        require(address(storage_map_a[var_a]), "ERC721: owner query for nonexistent token");
        emit Event_8c5be1e5(address(storage_map_a[var_a]), address(arg0), arg1);
        require(address(storage_map_a[var_a]) == msg.sender, "ERC721: approve caller is not owner nor approved for all");
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public
    function renounceOwnership() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        emit OwnershipTransferred(address(owner), 0);
        owner = uint96(owner);
    }
    
    /// @custom:selector    0x3ccfd60b
    /// @custom:signature   withdraw() public
    function withdraw() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        (bool success, bytes memory ret0) = address(msg.sender).transfer(address(this).balance);
    }
    
    /// @custom:selector    0x2f745c59
    /// @custom:signature   Unresolved_2f745c59(address arg0, uint256 arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_2f745c59(address arg0, uint256 arg1) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(address(arg0), "ERC721Enumerable: owner index out of bounds");
        address var_a = address(arg0);
        require(arg1 < storage_map_a[var_a], "ERC721Enumerable: owner index out of bounds");
        var_a = arg1;
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x55f804b3
    /// @custom:signature   Unresolved_55f804b3(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_55f804b3(uint256 arg0) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0 > 0xffffffffffffffff), "Ownable: caller is not the owner");
        require(!(((var_c + (uint248(0x3f + (arg0 + 0x1f)))) < var_c) | ((var_c + (uint248(0x3f + (arg0 + 0x1f)))) > 0xffffffffffffffff)), "Ownable: caller is not the owner");
        uint256 var_c = var_c + (uint248(0x3f + (arg0 + 0x1f)));
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(bytes1(store_e));
        require(!(bytes1(store_e)) == ((store_e >> 0x01) < 0x20));
        var_a = 0x0f;
        require(var_c.length);
        require(0x1f < var_c.length);
        store_e = 0x01 + (var_c.length + var_c.length);
        require(!var_c.length);
        require(!((var_c + 0x20) + var_c.length) > (var_c + 0x20));
        require(!(keccak256(var_a) + ((0x1f + (store_e >> 0x01)) / 0x20)) > keccak256(var_a));
    }
    
    /// @custom:selector    0x01ffc9a7
    /// @custom:signature   Unresolved_01ffc9a7(uint32 arg0) public pure returns (bool)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function Unresolved_01ffc9a7(uint32 arg0) public pure returns (bool) {
        require(arg0 == (uint32(arg0)));
        require(0x780e9d6300000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        return !(!0x780e9d6300000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        require(0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        require(0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        return !(!0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        return !(!(uint32(arg0)) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
    }
    
    /// @custom:selector    0xe985e9c5
    /// @custom:signature   Unresolved_e985e9c5(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_e985e9c5(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xc87b56dd
    /// @custom:signature   Unresolved_c87b56dd(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_c87b56dd(uint256 arg0) public view {
        uint256 var_a = arg0;
        if (address(storage_map_a[var_a])) {
            var_a = arg0;
            require(address(storage_map_a[var_a]), "ERC721Metadata: URI query for nonexistent token");
            require(bytes1(storage_map_a[var_a]), "ERC721Metadata: URI query for nonexistent token");
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!(bytes1(storage_map_a[var_a]) == ((storage_map_a[var_a] >> 0x01) < 0x20)), "ERC721Metadata: URI query for nonexistent token");
            require(bytes1(storage_map_a[var_a]), "ERC721Metadata: URI query for nonexistent token");
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!(bytes1(storage_map_a[var_a]) == ((storage_map_a[var_a] >> 0x01) < 0x20)), "ERC721Metadata: URI query for nonexistent token");
            require(!(storage_map_a[var_a] >> 0x01), "ERC721Metadata: URI query for nonexistent token");
            var_a = keccak256(var_a);
            require(0x1f < (storage_map_a[var_a] >> 0x01), "ERC721Metadata: URI query for nonexistent token");
        }
    }
    
    /// @custom:selector    0xa0712d68
    /// @custom:signature   mint(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function mint(uint256 arg0) public payable {
        require(bytes1(saleIsActive), "Purchase would exceed max supply");
        require(arg0 > 0, "Purchase would exceed max supply");
        require(!(unresolved_18160ddd > ~(arg0)), "Purchase would exceed max supply");
        require(!((unresolved_18160ddd + arg0) > MAX_SUPPLY), "Purchase would exceed max supply");
        require(!(arg0 > 0x05), "Can only mint up to 10 per purchase");
        require(!(0xb1a2bc2ec50000 & (arg0 > 0x0170ef54646d496892137dfd73f5a90f85ff1be02afb731a6e9f)), "Sent ether value is incorrect");
        require((0xb1a2bc2ec50000 * arg0) == msg.value, "Sent ether value is incorrect");
        var_d = 0x20;
        require(!(0 < arg0), "ERC721: token already minted");
        uint256 var_h = var_d + var_h;
        require(address(msg.sender), "ERC721: token already minted");
        var_a = unresolved_18160ddd;
        require(!(address(storage_map_a[var_a])), "ERC721: token already minted");
        require(0, "ERC721: transfer to non ERC721Receiver implementer");
        require(0 == (address(msg.sender)), "ERC721: transfer to non ERC721Receiver implementer");
        require(0, "ERC721: transfer to non ERC721Receiver implementer");
        uint256 var_a = 0;
        require(!(storage_map_a[var_a] < 0x01), "ERC721: transfer to non ERC721Receiver implementer");
        var_a = unresolved_18160ddd;
        require((storage_map_a[var_a] - 0x01) == storage_map_a[var_a], "ERC721: transfer to non ERC721Receiver implementer");
        var_a = unresolved_18160ddd;
        storage_map_a[var_a] = 0;
        var_a = storage_map_a[var_a] - 0x01;
        storage_map_a[var_a] = 0;
        require(!(!address(msg.sender)), "ERC721: transfer to non ERC721Receiver implementer");
        require(!(!address(msg.sender)), "ERC721: transfer to non ERC721Receiver implementer");
        require(!(!(address(msg.sender)) == 0), "ERC721: transfer to non ERC721Receiver implementer");
        require(!0x01, "ERC721: transfer to non ERC721Receiver implementer");
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] > 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe), "ERC721: transfer to non ERC721Receiver implementer");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_a[var_a] = storage_map_a[var_a] + 0x01;
        var_a = unresolved_18160ddd;
        storage_map_a[var_a] = (address(msg.sender)) | (uint96(storage_map_a[var_a]));
        emit Transfer(0, address(msg.sender), unresolved_18160ddd);
        require(!(address(msg.sender).code.length), "ERC721: transfer to non ERC721Receiver implementer");
        require(0x01, "ERC721: transfer to non ERC721Receiver implementer");
        require(!0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        address var_e = address(msg.sender);
        uint256 var_f = 0;
        require(!0 > var_h.length);
        require(address(msg.sender).code.length);
        (bool success, bytes memory ret0) = address(msg.sender).{ value: var_f ether }Unresolved_150b7a02(var_e); // call
        require(!ret0.length);
        require(var_n);
        var_h = var_h + (uint248(ret0.length + 0x3f));
        require(var_h.length, "ERC721: transfer to non ERC721Receiver implementer");
        var_h = var_h + (uint248(ret0.length + 0x1f));
        require(!((var_h + ret0.length) - var_h) < 0x20);
        require(var_h.length == (uint32(var_h.length)));
        require(0x01);
        require(!ret0.length);
        require(var_n);
        var_h = var_h + (uint248(ret0.length + 0x3f));
        require(var_h.length, "ERC721: transfer to non ERC721Receiver implementer");
        if (address(msg.sender) == 0) {
        }
    }
    
    /// @custom:selector    0xa22cb465
    /// @custom:signature   Unresolved_a22cb465(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_a22cb465(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        require(arg1 == arg1);
        require(!(msg.sender == (address(arg0))), "ERC721: approve to caller");
        var_a = address(arg0);
        storage_map_a[var_a] = arg1 | (uint248(storage_map_a[var_a]));
        emit Event_17307eab(msg.sender, address(arg0), arg1);
    }
    
    /// @custom:selector    0x4f6ccce7
    /// @custom:signature   Unresolved_4f6ccce7(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_4f6ccce7(uint256 arg0) public view returns (uint256) {
        require(arg0 < unresolved_18160ddd, "ERC721Enumerable: global index out of bounds");
        require(arg0 < unresolved_18160ddd, "ERC721Enumerable: global index out of bounds");
        var_a = 0x08;
        return storage_map_h[var_a];
    }
    
    /// @custom:selector    0x6352211e
    /// @custom:signature   Unresolved_6352211e(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_6352211e(uint256 arg0) public view returns (address) {
        uint256 var_a = arg0;
        require(address(storage_map_a[var_a]), "ERC721: owner query for nonexistent token");
        return address(storage_map_a[var_a]);
    }
    
    /// @custom:selector    0x34918dfd
    /// @custom:signature   flipSaleState() public
    function flipSaleState() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        saleIsActive = (!bytes1(saleIsActive)) | (uint248(saleIsActive));
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        if (store_i) {
            if (!(store_i) == ((store_i >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_i >> 0x01)) / 0x20) * 0x20));
                if (store_i) {
                    if (!(store_i) == ((store_i >> 0x01) < 0x20)) {
                        if (!store_i >> 0x01) {
                            if (0x1f < (store_i >> 0x01)) {
                                uint256 var_a = 0;
                                if ((0x20 + var_c) + (store_i >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked(0x20, var_c.length);
                                        return abi.encodePacked(0x20, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        if (store_j) {
            if (!(store_j) == ((store_j >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_j >> 0x01)) / 0x20) * 0x20));
                if (store_j) {
                    if (!(store_j) == ((store_j >> 0x01) < 0x20)) {
                        if (!store_j >> 0x01) {
                            if (0x1f < (store_j >> 0x01)) {
                                var_a = 0x01;
                                if ((0x20 + var_c) + (store_j >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked(0x20, var_c.length);
                                        return abi.encodePacked(0x20, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xe13f351a
    /// @custom:signature   calcStartingIndex() public
    function calcStartingIndex() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!startingIndex, "Starting index has already been set");
        require(startingIndexBlock, "Starting index has not been set yet");
        require(MAX_SUPPLY, "Starting index has not been set yet");
        startingIndex = blockhash(startingIndexBlock) % MAX_SUPPLY;
        require(!(block.number < startingIndexBlock), "Starting index has not been set yet");
        require(!((block.number - startingIndexBlock) > 0xff), "Starting index has not been set yet");
        require(startingIndex, "Starting index has not been set yet");
        require(!(startingIndex > 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe), "Starting index has not been set yet");
        startingIndex = startingIndex + 0x01;
    }
    
    /// @custom:selector    0xb88d4fde
    /// @custom:signature   Unresolved_b88d4fde(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_b88d4fde(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x081812fc
    /// @custom:signature   Unresolved_081812fc(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_081812fc(uint256 arg0) public view returns (address) {
        uint256 var_a = arg0;
        require(address(storage_map_a[var_a]), "ERC721: approved query for nonexistent token");
        var_a = arg0;
        return address(storage_map_a[var_a]);
    }
    
    /// @custom:selector    0xb07ed982
    /// @custom:signature   setMaxTokenSupply(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setMaxTokenSupply(uint256 arg0) public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        MAX_SUPPLY = arg0;
    }
    
    /// @custom:selector    0x42842e0e
    /// @custom:signature   Unresolved_42842e0e(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_42842e0e(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_23b872dd(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(address(arg0), "ERC721: balance query for the zero address");
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(address(arg0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(address(owner), address(arg0));
        owner = (address(arg0)) | (uint96(owner));
    }
    
    /// @custom:selector    0xd031370b
    /// @custom:signature   reserveTokens(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function reserveTokens(uint256 arg0) public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        var_b = 0x20;
        require(!(0 < arg0), "ERC721: token already minted");
        require(!(unresolved_18160ddd > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ERC721: token already minted");
        uint256 var_g = var_b + var_g;
        require(address(msg.sender), "ERC721: token already minted");
        uint256 var_e = unresolved_18160ddd + 0;
        require(!(address(storage_map_l[var_e])), "ERC721: token already minted");
        require(0, "ERC721: transfer to non ERC721Receiver implementer");
        require(0 == (address(msg.sender)), "ERC721: transfer to non ERC721Receiver implementer");
        require(0, "ERC721: transfer to non ERC721Receiver implementer");
        var_e = 0;
        require(!(storage_map_l[var_e] < 0x01), "ERC721: transfer to non ERC721Receiver implementer");
        var_e = unresolved_18160ddd + 0;
        require((storage_map_l[var_e] - 0x01) == storage_map_l[var_e], "ERC721: transfer to non ERC721Receiver implementer");
        var_e = unresolved_18160ddd + 0;
        storage_map_l[var_e] = 0;
        var_e = storage_map_l[var_e] - 0x01;
        storage_map_l[var_e] = 0;
        require(!(!address(msg.sender)), "ERC721: transfer to non ERC721Receiver implementer");
        require(!(!address(msg.sender)), "ERC721: transfer to non ERC721Receiver implementer");
        require(!(!(address(msg.sender)) == 0), "ERC721: transfer to non ERC721Receiver implementer");
        require(!0x01, "ERC721: transfer to non ERC721Receiver implementer");
        var_e = address(msg.sender);
        require(!(storage_map_l[var_e] > 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe), "ERC721: transfer to non ERC721Receiver implementer");
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_l[var_e] = storage_map_l[var_e] + 0x01;
        var_e = unresolved_18160ddd + 0;
        storage_map_l[var_e] = (address(msg.sender)) | (uint96(storage_map_l[var_e]));
        emit Transfer(0, address(msg.sender), unresolved_18160ddd + 0);
        require(!(address(msg.sender).code.length), "ERC721: transfer to non ERC721Receiver implementer");
        require(0x01, "ERC721: transfer to non ERC721Receiver implementer");
        require(!0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        address var_c = address(msg.sender);
        uint256 var_d = 0;
        require(!0 > var_g.length);
        require(address(msg.sender).code.length);
        (bool success, bytes memory ret0) = address(msg.sender).{ value: var_d ether }Unresolved_150b7a02(var_c); // call
        require(!ret0.length);
        require(var_n);
        var_g = var_g + (uint248(ret0.length + 0x3f));
        require(var_g.length, "ERC721: transfer to non ERC721Receiver implementer");
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        require(var_g.length == (uint32(var_g.length)));
        require(0x01);
        require(!ret0.length);
        require(var_n);
        var_g = var_g + (uint248(ret0.length + 0x3f));
        require(var_g.length, "ERC721: transfer to non ERC721Receiver implementer");
        if (address(msg.sender) == 0) {
        }
        require(startingIndexBlock);
        startingIndexBlock = block.number;
    }
    
    /// @custom:selector    0x7d17fcbe
    /// @custom:signature   emergencySetStartingIndexBlock() public
    function emergencySetStartingIndexBlock() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!startingIndex, "Starting index is already set");
        startingIndexBlock = block.number;
    }
}

ABI

[
  {
    "type": "function",
    "name": "MAX_NFT_PURCHASE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_SUPPLY",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "NFT_PRICE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_01ffc9a7",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_081812fc",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_18160ddd",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_2f745c59",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_42842e0e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_4f6ccce7",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_55f804b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_6352211e",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_a22cb465",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_b88d4fde",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_c87b56dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_e985e9c5",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcStartingIndex",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "emergencySetStartingIndexBlock",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "flipSaleState",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceOwnership",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "reserveTokens",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "saleIsActive",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setMaxTokenSupply",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "startingIndex",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "startingIndexBlock",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "withdraw",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "Event_17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipTransferred",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (5)

0x5b5e139f	unknown
0x80ac58cd	unknown
0x780e9d63	unknown
0x0a85bd01	unknown
0x72657373	unknown

These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)

0xce25e60a89f200b1fa40f6c313047ffe386992c3

DECOMPILED SOLIDITY (Heimdall) VERIFY

ABI

UNKNOWN SELECTORS (5)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

DECOMPILED SOLIDITY (Heimdall)