MIGRATED - do not buy

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

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

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

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

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

pragma solidity ^0.8.0;

import "../utils/Context.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 Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

//Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
// Creator : TheV

//  _______ __   __ _______    _______ _______ _______ __   __ _______    _______ _______ __    _ _______ 
// |       |  | |  |       |  |       |       |       |  |_|  |       |  |       |       |  |  | |       |
// |_     _|  |_|  |    ___|  |       |   _   |  _____|       |   _   |  |    ___|   _   |   |_| |    ___|
//   |   | |       |   |___   |      _|  | |  | |_____|       |  | |  |  |   | __|  |_|  |       |   | __ 
//   |   | |       |    ___|  |     | |  |_|  |_____  |       |  |_|  |  |   ||  |       |  _    |   ||  |
//   |   | |   _   |   |___   |     |_|       |_____| | ||_|| |       |  |   |_| |   _   | | |   |   |_| |
//   |___| |__| |__|_______|  |_______|_______|_______|_|   |_|_______|  |_______|__| |__|_|  |__|_______|

pragma solidity >=0.7.0;

import "https://github.com/chiru-labs/ERC721A/contracts/ERC721A.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";


contract CosmoGang is ERC721A, Ownable {
    enum Faction {None, Jahjahrion, Breedorok, Foodrak, Pimpmyridian,
        Muskarion, Lamborgardoz, Schumarian, Creatron}
    
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    uint256 public constant MAX_SUPPLY = 10000;
    mapping (uint256 => string) public tokenURIs;
    mapping (uint256 => Faction) public tokenFactions;
    uint256 public max_per_walet = 5;
    address public main_address = 0x9C21c877B44eBac7F0E8Ee99dB4ebFD4A9Ac5000;
    string public placeholder_uri = "https://bafybeih6b2d4aqvcsw6sv3cu2pi3doldwa4lq42w34ismwvfrictsod5nu.ipfs.infura-ipfs.io/";
    string public base_uri;
    bool public isMinting = false;
    bool public isRevealed = false;
    bool public isBaseUri = false;
    uint256 public price = 0 ether;
    uint256 public current_supply = 2000;

    constructor() ERC721A("TheCosmoGang", "CG")
    {
        // Minting for availability on OpenSea before any mint
        _safeMint(address(this), 1);
        _burn(0);
    }

    function toggleMintState()
        public onlyOwner
    {
        if (isMinting)
        {
            isMinting = false;
        }
        else
        {
            isMinting = true;
        }
    }

    function toggleRevealState()
        public onlyOwner
    {
        if (isRevealed)
        {
            isRevealed = false;
        }
        else
        {
            isRevealed = true;
        }
    }

    function toggleBaseUriState()
        public onlyOwner
    {
        if (isBaseUri)
        {
            isBaseUri = false;
        }
        else
        {
            isBaseUri = true;
        }
    }

    // Mint Logic
    function _mintNFT(uint256 nMint, address recipient)
        private
        returns (uint256[] memory)
    {
        require(_tokenIds.current() + nMint <= MAX_SUPPLY, "No more NFT to mint");
        require(_tokenIds.current() + nMint <= current_supply, "No more NFT to mint currently");
        require(balanceOf(recipient) + nMint <= max_per_walet, "Too much NFT minted");
        
        current_supply -= nMint;
        uint256[] memory newItemIds = new uint256[](nMint);

        for (uint256 i = 0; i < nMint; i++)
        {
            _tokenIds.increment();
            uint256 newItemId = _tokenIds.current();
            newItemIds[i] = newItemId;
        }
        _safeMint(recipient, nMint);
        // _mint(recipient, nMint);

        return newItemIds;
    }

    // Normal Mint
    function mintNFT(uint256 nMint, address recipient)
        external payable
        returns (uint256[] memory)
    {
        require(isMinting, "Mint period have not started yet");
        require(msg.value >= price * nMint, "Not enough ETH to mint");

        return _mintNFT(nMint, recipient);
    }

    // Free Mint
    function giveaway(uint256 nMint, address recipient)
        external onlyOwner
        returns (uint256[] memory)
    {
        return _mintNFT(nMint, recipient);
    }

    function burnNFT(uint256 tokenId)
        external onlyOwner
    {
        _burn(tokenId);
        delete tokenURIs[tokenId];
    }

    function setCurrentSupply(uint256 supply)
        external onlyOwner
    {
        require(getCurrentSupply() + supply <= MAX_SUPPLY, "Too much supply");
        current_supply = supply;
    }

    function transferFrom(address from, address to, uint256 tokenId)
        public
        override
    {
        require(balanceOf(from) > 1, "Not enough NFT to send one");
        super.transferFrom(from, to, tokenId);
    }

    function tokenURI(uint256 tokenId)
        public view
        override
        returns (string memory)
    {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        if (isRevealed)
        {
            if (isBaseUri)
            {
                return string(abi.encodePacked(abi.encodePacked(abi.encodePacked(base_uri, "/"), Strings.toString(tokenId)), ".json"));
            }
            else
            {
                return tokenURIs[tokenId];
            }
            
        }
        else
        {
            return placeholder_uri;
        }
    }

    function setTokenURI(uint256 tokenId, string memory _tokenURI, Faction faction)
        private
        // override(ERC721)
    {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        tokenURIs[tokenId] = _tokenURI;
        tokenFactions[tokenId] = faction;
    }

    function updateTokenURI(uint256 tokenId, string memory _tokenURI, Faction faction)
        external onlyOwner
        // override(ERC721A)
    {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        tokenURIs[tokenId] = _tokenURI;
        tokenFactions[tokenId] = faction;
    }

    function updateAllTokenURIs(uint256[] memory tokenIds, string[] memory _tokenURIs, Faction[] memory factions)
        external onlyOwner
        // override(ERC721A)
    {
        mapping(uint256 => string) storage tempTokenURIs = tokenURIs;
        mapping(uint256 => Faction) storage tempTokenFactions = tokenFactions;
        for (uint256 idx = 0; idx <= tokenIds.length; idx++)
        {
            uint256 tokenId = tokenIds[idx];
            string memory _tokenURI = _tokenURIs[idx];
            Faction tokenFaction = factions[idx];
            require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
            tempTokenURIs[tokenId] = _tokenURI;
            tempTokenFactions[tokenId] = tokenFaction;
        }
    }

    function setFaction(uint256 tokenId, Faction _faction)
        external onlyOwner
    {
        tokenFactions[tokenId] = _faction;
    }
    
    function setPrice(uint256 priceGwei)
        external onlyOwner
    {
        price = priceGwei * 10**9;
    }

    function setPlaceholderUri(string memory _placeholder_uri)
        external onlyOwner
    {
        placeholder_uri = _placeholder_uri;
    }

    function setBaseUri(string memory _base_uri)
        external onlyOwner
    {
        base_uri = _base_uri;
    }

    function setMaxPerWallet(uint256 _max_per_wallet)
        external onlyOwner
    {
        max_per_walet = _max_per_wallet;
    }

    function setMainAddress(address _main_address)
        external onlyOwner
    {
        main_address = _main_address;
    }

    function getTokenIds()
        external view onlyOwner
        returns (uint256[] memory)
    {   
        uint256 idx = 0;
        uint256 totalSupply = totalSupply();
        uint256[] memory tokenIds = new uint256[](totalSupply);
        for (uint256 i; i <= _tokenIds.current(); i++)
        {
            if (_exists(i))
            {
                tokenIds[idx] = i;
                idx++;
            }
        }
        return tokenIds;
    }
    
    function getTokenIdsOf(address addr)
        external view onlyOwner
        returns (uint256[] memory)
    {
        uint256 count = balanceOf(addr);
        uint256[] memory tokenIds = new uint256[](count);
        uint256 foundTokens = 0;
        for (uint256 i; i <= _tokenIds.current(); i++)
        {
            if (_exists(i))
            {
                if (ownerOf(i) == addr)
                {
                    tokenIds[foundTokens] = i;
                    foundTokens++;
                }
            }
        }
    
        return tokenIds;
    }

    function getHolders()
        external view onlyOwner
        returns (address[] memory)
    {
        uint256 supply = getCurrentSupply();
        address[] memory holders = new address[](supply);
        uint256 idx = 0;
        for (uint256 i; i <= _tokenIds.current(); i++)
        {
            if (_exists(i))
            {
                address holder = ownerOf(i);
                bool alreadyAdded = false;
                for (uint256 j; j < holders.length; j++)
                {
                    if (holders[j] == holder)
                    {
                        alreadyAdded = true;
                    }
                }
                if (!alreadyAdded)
                {
                    holders[idx] = holder;
                    idx++;
                }
            }
        }

        return holders;
    }

    function getCurrentSupply()
        public view
        returns (uint256)
    {
        return totalSupply();
    }

    function isHolder(address addr)
        public view
        returns (bool)
    {
        return balanceOf(addr) > 0;
    }

    function withdraw()
        public 
        payable
    {
        uint256 amount = address(this).balance;
        require(amount > 0, "Nothing to withdraw");
        bool success = payable(main_address).send(amount);
        require(success, "Failed to withdraw");
    }

    function getETHBalance(address addr)
        public view
        returns (uint)
    {
        return addr.balance;
    }

    function getContractBalance()
        public view
        returns (uint256)
    {
        return address(this).balance;
    }

    receive()
        external payable
    {
        // balance[msg.sender] += msg.value;
    }

    fallback()
        external
    {

    }
}

{
  "compilationTarget": {
    "main_erc721_nft_smart_contract/smart_contract_opti.sol": "CosmoGang"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}