Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.7;


import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/structs/EnumerableSetUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";


interface HeadStaking {
    function depositsOf(address account) external view returns (uint256[] memory);
}

interface IHead {
    function mint(address to, uint256 amount) external;
    function burn(address from, uint256 amount) external;
    function updateOriginAccess() external;
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

interface IStaking {
  function stakeMany(address account, uint16[] calldata tokenIds) external;
  function randomHunterOwner(uint256 seed) external view returns (address);
}

interface IMint {
  struct Traits {uint8 alphaIndex; bool isHunter;}
  function getPaidTokens() external view returns (uint256);
  function getTokenTraits(uint256 tokenId) external view returns (Traits memory);
  function minted() external view returns (uint16);
  function mint(address recipient) external;

}

contract paymentContract is ReentrancyGuardUpgradeable, OwnableUpgradeable, PausableUpgradeable  {
  
  IStaking public stakingContract;                                          
  IHead public ERC20Token;               
  IMint public ERC721Contract;      
  HeadStaking public HeadDAOStaking;   

  
  using AddressUpgradeable for address;
  using EnumerableSetUpgradeable for EnumerableSetUpgradeable.UintSet; 
  using CountersUpgradeable for CountersUpgradeable.Counter;



  struct PendingCommits {bool stake; uint16 amount;}

  uint256 public HeadDaoMinted;
  uint256 public HeadDAOExpiry;
  uint256 private pendingMintAmt;

  bool public hasPublicSaleStarted;

  mapping (address => uint256) public daoMints;
  mapping (address => bool)     private whitelistedContracts;    
  mapping(uint256 => uint256) private _tokenIndex; 
  mapping(address => uint256) private _pendingCommitId;  
  mapping(address => mapping(uint256 => PendingCommits)) private _pendingCommits;        
  mapping (uint16 => bool) public daoUsedTokens;  
  mapping(address => bool)      public  whitelists;           

  uint256 public MAX_TOKENS;    
  uint256 private PAID_TOKENS;         
  uint256 public MINT_PRICE;    

  uint256[] internal seeds;  
  uint256 seed_interval;
  uint256 _nextID;

  function initialize(uint256 _maxTokens) initializer public {

    __Ownable_init();
    __ReentrancyGuard_init();
    __Pausable_init();
    _pause();

    MINT_PRICE = 0.07 ether;   
    MAX_TOKENS = _maxTokens;
    PAID_TOKENS = _maxTokens / 5;
    _nextID = 0;
    seed_interval = 100;
    HeadDAOExpiry = block.timestamp + 172800;

    _addSeed();


  }


  function commitMint(uint256 amount, bool stake) external payable whenNotPaused {
    address msgSender = _msgSender();
    uint256 minted = ERC721Contract.minted() + pendingMintAmt;

    require(hasPublicSaleStarted,"Public Sale is not live");
    require(tx.origin == msgSender, "Only EOA");
    require(minted + amount <= MAX_TOKENS, "All tokens minted");
    require(amount > 0 && amount <= 10, "Invalid mint amount");

    require(_pendingCommitId[msgSender] == 0, "Already have pending mints");

    if (minted < PAID_TOKENS) {
      require(minted + amount <= PAID_TOKENS, "All tokens on-sale already sold");
      require(MINT_PRICE * amount == msg.value, "Invalid payment amount");
    } else {
      require(msg.value == 0);

    }
    uint256 headCost = 0;   

    for (uint i = 0; i < amount; i++) {
      minted++;
      if (minted % seed_interval == 0){
        _addSeed();
      }

      headCost += mintCost(minted);
    }

    if (headCost > 0) {
      ERC20Token.burn(msgSender, headCost);
    }

    uint16 amt = uint16(amount);
    _pendingCommits[msgSender][_nextID] = PendingCommits(stake, amt);
    _pendingCommitId[msgSender] = _nextID;
    pendingMintAmt += amount;

  }
  
  mapping(uint256 => address) private headDaoOwners; 

  function commitMint_whitelist(bool stake) external  whenNotPaused {
    address msgSender = _msgSender();
    uint256 minted = ERC721Contract.minted() + pendingMintAmt;
    uint256 amount = 1;

    require(block.timestamp < HeadDAOExpiry, "the free mint timeframe is over");
    require(minted >= PAID_TOKENS, "Head DAO Minting phase not started");
    require(minted + amount <= MAX_TOKENS, "All tokens minted");
    require(HeadDaoMinted + amount <= 10000, "No more Head DAO free mints Left");
    require(amount > 0 && amount <= 10, "Invalid Amount to mint");
    require(tx.origin == msgSender, "Only EOA");
    require(whitelists[msgSender], "You are not whitelisted");
    require(_pendingCommitId[msgSender] == 0, "Already have pending mints");

    HeadDaoMinted += amount;
    whitelists[msgSender] = false;

    for (uint i = 0; i < amount; i++) {      
      minted++;
      if (minted % seed_interval == 0){
        _addSeed();
      }
    }

    uint16 amt = uint16(amount);
    _pendingCommits[msgSender][_nextID] = PendingCommits(stake, amt);
    _pendingCommitId[msgSender] = _nextID;
    pendingMintAmt += amount;

  }


  mapping(address => mapping (uint => bool)) private stakedTokenIDs;

  function commitMint_headDAO(uint16[] calldata daotokenIds, bool stake) external whenNotPaused {
    address msgSender = _msgSender();
    uint256 minted = ERC721Contract.minted() + pendingMintAmt;
    uint256[] memory deposits = HeadDAOStaking.depositsOf(msgSender);
    uint256 amount = daotokenIds.length;

    require(deposits.length > 0, "You are not a staker");
    require(block.timestamp < HeadDAOExpiry, "the free mint timeframe is over");
    require(minted >= PAID_TOKENS, "Head DAO Minting phase not started");
    require(minted + amount <= MAX_TOKENS, "All tokens minted");
    require(HeadDaoMinted + amount <= 10000, "No more Head DAO free mints Left");
    require(amount > 0 && amount <= 10, "Invalid Amount to mint");
    require(tx.origin == msgSender, "Only EOA");

    require(_pendingCommitId[msgSender] == 0, "Already have pending mints");

    daoMints[msgSender] += amount;
    HeadDaoMinted += amount;

    for (uint i = 0; i < deposits.length; i++) {
      stakedTokenIDs[msgSender][deposits[i]] = true;
    }

    for (uint i = 0; i < amount; i++) {
      uint16 daoTokenID = daotokenIds[i];
      require(!daoUsedTokens[daoTokenID],"Token Already Used to Mint");
      require(stakedTokenIDs[msgSender][daoTokenID], "You don't own this Token ID");

      daoUsedTokens[daoTokenID] = true;
      minted++;
      if (minted % seed_interval == 0){
        _addSeed();
      }
    }

    uint16 amt = uint16(amount);
    _pendingCommits[msgSender][_nextID] = PendingCommits(stake, amt);
    _pendingCommitId[msgSender] = _nextID;
    pendingMintAmt += amount;

  }

  

  function reveal(address addr) internal {

    uint256 _seedID = _pendingCommitId[addr];
    require(_seedID > 0, "No pending commit");
    require(seeds[_seedID] != 0, "seed is Not ready");

    PendingCommits memory commit = _pendingCommits[addr][_seedID];

    uint16 amount = commit.amount;
    uint16[] memory tokenIds = new uint16[](amount);
    uint16 minted = ERC721Contract.minted();
    uint256 seed = seeds[_seedID];

    pendingMintAmt -= amount;
    _pendingCommitId[addr] = 0;

    for (uint i = 0; i < amount; i++) {
      
      minted++;      
      uint256 receip_seed = uint256(keccak256(abi.encodePacked(seed,minted)));                                                                                                        
      address recipient = selectRecipient(receip_seed,minted);    
      
      if (!commit.stake) {                                           
        ERC721Contract.mint(recipient);

      } else {
        ERC721Contract.mint(address(stakingContract));
        tokenIds[i] = minted;
      }

 
      _tokenIndex[minted] = _seedID;

    }

    if (commit.stake) stakingContract.stakeMany(addr, tokenIds);

    delete _pendingCommits[addr][_seedID];
    

  }

  function mintReveal() external whenNotPaused nonReentrant {
    require(tx.origin == _msgSender() && !_msgSender().isContract(), "Only EOA1");

    reveal(_msgSender());
  }

  function setPublicSaleStart(bool started) external onlyOwner {
    hasPublicSaleStarted = started;
  }

  function selectRecipient(uint256 seed, uint256 minted) private view returns (address) {

    
    if (minted <= PAID_TOKENS || ((seed >> 245) % 10) != 0) return _msgSender();  

    address thief = stakingContract.randomHunterOwner(seed >> 144);                                         
    if (thief == address(0x0)) return _msgSender();
    return thief;

  }

  function mintCost(uint256 tokenId) public view returns (uint256) {
    if (tokenId <= PAID_TOKENS) return 0;                           
    if (tokenId <= 30000 ) return 200 ether;          
    if (tokenId <= 40000) return 400 ether;         
    return 800 ether;                                            
  }

  function setWhitelistContract(address contract_address, bool status) public onlyOwner{
      whitelistedContracts[contract_address] = status;
  }

  function setStaking(address _staking) external onlyOwner {
    stakingContract = IStaking(_staking);
  }

  function setERC20token(address _erc20Address) external onlyOwner {
      ERC20Token = IHead(_erc20Address);  
  }

  function setERC721Contract(address _mintContract) external onlyOwner {
    ERC721Contract = IMint(_mintContract);
  }
  
  function setInit(address _mintContract, address _staking, address _erc20Address, address _headdaostaking) public onlyOwner {
    stakingContract = IStaking(_staking);
    ERC20Token = IHead(_erc20Address);  
    ERC721Contract = IMint(_mintContract);
    HeadDAOStaking = HeadStaking(_headdaostaking);  
    
  }

  function setPaidTokens(uint256 _paidTokens) external onlyOwner {
    PAID_TOKENS = _paidTokens;
  }

  function setPaused(bool _paused) external onlyOwner {
    require(address(ERC20Token) != address(0) && address(stakingContract) != address(0), "Contracts are not set");
    if (_paused) _pause();
    else _unpause();
  }

  function withdraw() public payable onlyOwner {
    
    uint256 ddungeon = (address(this).balance * 35) / 100;  
    uint256 modPay = (address(this).balance * 5) / 100;  
    uint256 daoPortion = (address(this).balance * 15) / 100;        
    uint256 dev = (address(this).balance * 85) / 1000;  
    uint256 verd = (address(this).balance * 4) / 100;  
    uint256 security = (address(this).balance * 5) / 100;  
    uint256 extra = (address(this).balance * 5) / 100;  
    uint256 sham = (address(this).balance * 225) / 1000;  

		payable(0x11360F0c5552443b33720a44408aba01a809905e).transfer(sham);
    payable(0x177F994565d8bbA819D45b5a32C962ED091B9dA5).transfer(modPay);
    payable(0xf2018871debce291588B4034DBf6b08dfB0EE0DC).transfer(daoPortion);
    payable(0x9C8227FE7FE01F8278da8F7b9963Ed38c0603577).transfer(extra);
    payable(0x09814aaf2a03d944833180C2a4Dcaa2612fa672d).transfer(ddungeon);
    payable(0xE2e35768cC25d0120D719f64eaC64cf6efFfff45).transfer(security);
    payable(0x2D3840C060dfb7f311E08fe3c1e21Feca6C74B56).transfer(dev);
    payable(0xA684399B5230940a84a17be6340369D7A18A664F).transfer(verd);

  }

  function setDAOexpiry(uint256 _new) external onlyOwner {
    HeadDAOExpiry = _new;
  }

  function testMint() external onlyOwner {
    MINT_PRICE = 0;
  }

  // SEED 
  function get_seed(uint256 tokenId) external view returns (uint256) {
    uint256 seedIndex = _tokenIndex[tokenId];
    require(seeds[seedIndex] != 0, "seed is Not ready");
    return seeds[seedIndex];

  }

  function last_seed() external view returns (uint256) {
    return seeds[seeds.length-1];

  }

  function changeSeedInterval(uint256 _new) external onlyOwner{
    seed_interval = _new;
  }

  function _addSeed() private {
    seeds.push(uint256(blockhash(block.number - 1)));
    _nextID ++;   
  }

  function force_seed() external onlyOwner {
    _addSeed();
  }

  function addRandomSeed(uint256 seed) external {
    require(owner() == _msgSender() || whitelistedContracts[_msgSender()], "Only admins can call this");
    seeds.push(seed);
    _nextID ++;   
  }

  // Commit Stuff
  function getPendingMint(address addr) external view returns (PendingCommits memory) {
    require(_pendingCommitId[addr] != 0, "no pending commits");
    return _pendingCommits[addr][_pendingCommitId[addr]];
  }

  function hasMintPending(address addr) external view returns (bool) {
    return _pendingCommitId[addr] != 0;
  }
  
  function canMint(address addr) external view returns (bool) {
    return _pendingCommitId[addr] != 0 && seeds[_pendingCommitId[addr]] > 0;
  }

  function forceRevealCommit(address addr) external {
    require(owner() == _msgSender() || whitelistedContracts[_msgSender()], "Only admins can call this");
    reveal(addr);
  }

  function add_whitelist(address[] calldata addresses) external onlyOwner {
    uint256 length = addresses.length;
    for (uint256 i; i < length; i++ ){
          whitelists[addresses[i]] = true;
    }
  }

  function getPaidTokens() external view returns (uint256) {
    return PAID_TOKENS;
  }

  function getInterval() external view returns (uint256) {
    return seed_interval;
  }

  function getTotalMinted() external view returns (uint256){
    uint256 minted = ERC721Contract.minted() + pendingMintAmt;
    return minted;
  }


  function withdrawNew() public payable onlyOwner {
    
    uint256 ddungeon = (address(this).balance * 35) / 100;  
    uint256 modPay = (address(this).balance * 5) / 100;  
    uint256 daoPortion = (address(this).balance * 15) / 100;        
    uint256 dev = (address(this).balance * 85) / 1000;  
    uint256 verd = (address(this).balance * 4) / 100;  
    uint256 security = (address(this).balance * 5) / 100;  
    uint256 extra = (address(this).balance * 5) / 100;  
    uint256 sham = (address(this).balance * 225) / 1000;  

		payable(0x11360F0c5552443b33720a44408aba01a809905e).transfer(sham);
    payable(0x177F994565d8bbA819D45b5a32C962ED091B9dA5).transfer(modPay);
    payable(0xC7216f7AAE4C253962d30693EB15023e80C04633).transfer(daoPortion);
    payable(0x9C8227FE7FE01F8278da8F7b9963Ed38c0603577).transfer(extra);
    payable(0x09814aaf2a03d944833180C2a4Dcaa2612fa672d).transfer(ddungeon);
    payable(0xE2e35768cC25d0120D719f64eaC64cf6efFfff45).transfer(security);
    payable(0x2D3840C060dfb7f311E08fe3c1e21Feca6C74B56).transfer(dev);
    payable(0xA684399B5230940a84a17be6340369D7A18A664F).transfer(verd);

  }



}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSetUpgradeable {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library 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 {
            counter._value += 1;
        }
    }

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

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

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

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;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)

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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @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 ReentrancyGuardUpgradeable is Initializable {
    // 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.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    function __ReentrancyGuard_init() internal initializer {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal initializer {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal initializer {
        __Context_init_unchained();
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal initializer {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.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 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.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To initialize the implementation contract, you can either invoke the
 * initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() initializer {}
 * ```
 * ====
 */
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;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

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.
     */
    function __Ownable_init() internal initializer {
        __Context_init_unchained();
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal initializer {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
    uint256[49] private __gap;
}

{
  "remappings": [],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "london",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"ERC20Token","outputs":[{"internalType":"contract IHead","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ERC721Contract","outputs":[{"internalType":"contract IMint","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HeadDAOExpiry","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HeadDAOStaking","outputs":[{"internalType":"contract HeadStaking","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HeadDaoMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINT_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"seed","type":"uint256"}],"name":"addRandomSeed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"add_whitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"canMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_new","type":"uint256"}],"name":"changeSeedInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"stake","type":"bool"}],"name":"commitMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"daotokenIds","type":"uint16[]"},{"internalType":"bool","name":"stake","type":"bool"}],"name":"commitMint_headDAO","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"stake","type":"bool"}],"name":"commitMint_whitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"daoMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"","type":"uint16"}],"name":"daoUsedTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"forceRevealCommit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"force_seed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPaidTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getPendingMint","outputs":[{"components":[{"internalType":"bool","name":"stake","type":"bool"},{"internalType":"uint16","name":"amount","type":"uint16"}],"internalType":"struct paymentContract.PendingCommits","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"get_seed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"hasMintPending","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasPublicSaleStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxTokens","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"last_seed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_new","type":"uint256"}],"name":"setDAOexpiry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20Address","type":"address"}],"name":"setERC20token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_mintContract","type":"address"}],"name":"setERC721Contract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_mintContract","type":"address"},{"internalType":"address","name":"_staking","type":"address"},{"internalType":"address","name":"_erc20Address","type":"address"},{"internalType":"address","name":"_headdaostaking","type":"address"}],"name":"setInit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_paidTokens","type":"uint256"}],"name":"setPaidTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"started","type":"bool"}],"name":"setPublicSaleStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_staking","type":"address"}],"name":"setStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contract_address","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setWhitelistContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingContract","outputs":[{"internalType":"contract IStaking","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"testMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawNew","outputs":[],"stateMutability":"payable","type":"function"}]

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