NFTBaseERC1155.sol

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

import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";


contract NFTBaseERC1155 is ERC1155, Ownable, Pausable, ERC1155Burnable, ERC1155Supply {

   uint16[] supplies=[100,200,300]; //Total No of nft that can me minted
   uint16[] minted=[0,0,0];  //Total nft minted
   uint256[] rates=[1 ether,3 ether,5 ether]; //Price for minting nft

   mapping(uint256 => address) private _owners;

    constructor() ERC1155("https://nftstorage.link/ipfs/bafybeie3to4rlzcmksld2zyevtmectcgyu5oleslijbzb42acglxivgkny/{id}.json") {}

    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

  modifier check_nft_type_balance_and_supply(uint16 id,uint16 amount) {
       require(id<=supplies.length,"Token doesn't exist");
       require(id>0,"Token doesn't exist");
       require((minted[returnIndex(id)]+amount)<=supplies[returnIndex(id)],"Not enough supply");
       require(msg.value>=amount*rates[returnIndex(id)],"Not enough balance");
       _;
  }

  function returnIndex(uint16 index)public pure returns(uint16){
      return index-1;
  }

    function mint(uint16 id, uint16 amount)
        public payable check_nft_type_balance_and_supply(id,amount)
    {
        _mint(msg.sender,id,amount,"");
        minted[returnIndex(id)]+=amount;
    }


    function MintBatch() public{

      for(uint16 i=2; i<=43; i++){
        _mint(msg.sender,i,1,"");
        _owners[i]=msg.sender;
      }
    }

  function withdraw() public onlyOwner {
    require(address(this).balance >0,"Balance is zero");
    payable(owner()).transfer(address(this).balance);
  }

    function _beforeTokenTransfer(address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
        internal
        whenNotPaused
        override(ERC1155, ERC1155Supply)
    {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }


        function uri(uint256 _tokenid) override public pure returns (string memory) {
        return string(
            abi.encodePacked(
                "https://nftstorage.link/ipfs/bafybeie3to4rlzcmksld2zyevtmectcgyu5oleslijbzb42acglxivgkny/",
                Strings.toString(_tokenid),".json"
            )
        );

    }

        function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC1155: owner query for nonexistent token");
        return owner;
    }


}