NFT Contract Generator (BETA)

// SPDX-License-Identifier: MIT

//Powered By LazyDevs
//!Disclaimer!
//    please review this code on your own before using any of
//    the following code for production.
//    LazyDevs will not be liable in any way if for the use 
//    of the code. That being said, the code has been tested 
//    to the best of the developers' knowledge to work as intended.
//    If you find any problems please let the dev know in order to improve
//    the contract and fix vulnerabilities if there is one.


pragma solidity ^0.8.10;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract LazyDevs is ERC721, Ownable, ReentrancyGuard {
    using Strings for uint256;
    using Counters for Counters.Counter;

    uint256 price;
    uint256 _maxSupply;
    uint256 maxMintAmountPerTx;
    uint256 maxMintAmountPerWallet;

    string baseURL = "";
    string ExtensionURL = ".json";
    

    
    
    
    bool paused = false;

    Counters.Counter private _tokenIdCounter;
    
    constructor(uint256 _price, uint256 __maxSupply, string memory _initBaseURI, uint256 _maxMintAmountPerTx, uint256 _maxMintAmountPerWallet) ERC721("Lazy Devs", "LDS") {

        baseURL = _initBaseURI;
        price = _price;
        _maxSupply = __maxSupply;
        maxMintAmountPerTx = _maxMintAmountPerTx;
        maxMintAmountPerWallet = _maxMintAmountPerWallet;
        
        

        
    }

    // ================= Mint Function =======================

    function Mint(address to, uint256 _mintAmount) public payable{
        uint256 tokenId = _tokenIdCounter.current();
        require(!paused, "The contract is paused!");
        require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
        require(currentSupply() + _mintAmount <= _maxSupply, "Max supply exceeded!");
        require(msg.value >= price * _mintAmount, "You dont have enough funds!");
        require(balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerWallet, "Max mint per wallet exceeded!");
        
        

        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
    }

        

    // =================== Orange Functions (Owner Only) ===============

    function pause(bool state) public onlyOwner {
        paused = state;
    }

    function safeMint(address to) public onlyOwner {
        uint256 tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
    }

    

    

    function setbaseURL(string memory uri) public onlyOwner{
        baseURL = uri;
    }

    function setExtensionURL(string memory uri) public onlyOwner{
        ExtensionURL = uri;
    }

    // ================== Withdraw Function =============================
    function withdraw() public onlyOwner nonReentrant{
        uint256 CurrentContractBalance = address(this).balance;

        (bool os, ) = payable(owner()).call{value: CurrentContractBalance}("");
        require(os);

    }

    // =================== Blue Functions (View Only) ====================

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

    

        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0
            ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), ExtensionURL))
            : '';
    }

    function cost() public view returns (uint256){
        return price;
    }

    function _baseURI() internal view virtual override returns (string memory) {
    return baseURL;
    }
    function currentSupply() public view returns (uint256){
        return _tokenIdCounter.current();
    }

    function maxSupply() public view returns (uint256){
        return _maxSupply;
    }

    function setCostPrice(uint256 _cost) public onlyOwner{
        price = _cost;
    } 

    function setSupply(uint256 supply) public onlyOwner{
        _maxSupply = supply;
    }
    
    // ================ Internal Functions ===================

    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override{
        super._beforeTokenTransfer(from, to, tokenId);
    }

}
//Powered By LazyDevs