DoodlDuckz

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

    constructor() {
        _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 make 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;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract DoodlDuckz is ERC721, ReentrancyGuard, Ownable {
    uint256 public MINT_PRICE = 0.05 ether;
    uint256 public TOTAL_SUPPLY = 5555;
    bool public MINTING_ALLOWED = false;
    string private _baseURIextended;
    uint256 private _counter = 0;

    using Strings for uint256;
   
   mapping(uint256 => string) private _tokenURIs;
   
    constructor(
        string memory _name,
        string memory _symbol
    ) ERC721(_name, _symbol) {}

    function contractURI() public view returns (string memory) {
        return _baseURI();
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return _baseURIextended;
    }

    /*
     * Owner can withdraw the contract's ETH to an external address
     */
    function withdrawETH(address ethAddress, uint256 amount) public onlyOwner {
        payable(ethAddress).transfer(amount);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }


    /*
     * Mint function
     */

    function mint(uint requestedTokens) public payable nonReentrant() {
      require(MINTING_ALLOWED, "Minting is not allowed");

      require(
       requestedTokens <= TOTAL_SUPPLY - _counter,
       "There aren't this many DDZ left."
      );

      require(
       requestedTokens <= 10,
       "Up to 10 tokens allowed in a single minting transaction."
      );

      require(TOTAL_SUPPLY - _counter>0,"DDZ shares are now sold out! Please check OpenSea to purchase DDZ .");


      uint256 totalCost = getMintingCost(requestedTokens);
      require(
       msg.value >= totalCost,
       "Insufficient Gas."
      );
   
        for(uint i = 0; i < requestedTokens; i++) {
           _mint(msg.sender, _counter + 1);
           _setTokenURI(_counter + 1, Strings.toString(_counter + 1));
           _counter++;
        }
        //payable(OWNER).transfer(msg.value);
    }

   //Return minting cost
  function getMintingCost(uint totalItems)
    private
    view
    returns (uint256)
  {
    return totalItems * MINT_PRICE;
  }

    function totalTokensMinted() public view returns (uint256) {
        return _counter;
    }

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

   function remainingSupply() public view returns (uint256) {
        return TOTAL_SUPPLY - _counter;
    }


   function setMintPrice(uint256 newPrice) external onlyOwner {
        MINT_PRICE = newPrice;
        MINTING_ALLOWED = false;
    }

    //Set the Base URI
    function setBaseURI(string memory baseURI_) external onlyOwner {
        _baseURIextended = baseURI_;
    }

    function _setTokenURI(uint256 tokenId, string memory _tokenURI)
        internal
        virtual
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI set of nonexistent token"
        );
        _tokenURIs[tokenId] = _tokenURI;
    }

    function setMintingFlag() external onlyOwner {
        MINTING_ALLOWED = !MINTING_ALLOWED;
    }
}

{
  "compilationTarget": {
    "contracts/doodleduckz.sol": "DoodlDuckz"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}