Ninjalerts Lifetime License

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/ERC1155.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol";
import {MerkleProof} from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

contract NinjalertsLifetimeNFT is ERC1155, Ownable {
    enum SaleStatus{STOPPED, WHITE_LIST, PUBLIC}
    using MerkleProof for bytes32[];
    SaleStatus public saleStatus;
    uint256 public tokensRemaining = 3529;
    uint256 public maxPublicMintPerTx = 5;
    uint256 public cost = 0.25 ether;
    uint256 public constant NINJALERT_NFT = 0;
    bytes32 merkleRoot1;
    bytes32 merkleRoot2;
    mapping (address => uint256) public whitelistMintCount;
    
    constructor() ERC1155("https://dknz9qml3u41j.cloudfront.net/ninjalerts/token/{id}.json") {
        saleStatus = SaleStatus.STOPPED;
    }
    
    function withdraw() public payable onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }
    
    function setWhitelist(bytes32 list1Root, bytes32 list2Root) public onlyOwner {
        merkleRoot1 = list1Root;
        merkleRoot2 = list2Root;
    }
    
    function startWhitelistSale(bytes32 list1Root, bytes32 list2Root) public onlyOwner {
        setWhitelist(list1Root, list2Root);
        saleStatus = SaleStatus.WHITE_LIST;
    }
    
    function startPublicSale() public onlyOwner {
        saleStatus = SaleStatus.PUBLIC;
    }
    
    function stopMint() public onlyOwner {
        saleStatus = SaleStatus.STOPPED;
    }
    
    modifier whiteList(bytes32 merkleRoot, bytes32[] memory proof) {
        require(saleStatus == SaleStatus.WHITE_LIST, "whitelist sale currently unavailable.");
        require(proof.verify(merkleRoot, keccak256(abi.encodePacked(msg.sender))));
        _;
    }
    
    modifier mintable(uint256 amount) {
        require(amount>0,"amount must be positive integer.");
        require(msg.value >= amount * cost, "Ether insufficient.");
        require(amount <= tokensRemaining);
        _;
    }
    
    function mint(uint256 amount) internal {
        _mint(msg.sender, NINJALERT_NFT, amount, "");
        tokensRemaining -= amount; 
    }
    
    
    function whitelist1Mint(bytes32[] memory proof) public payable whiteList(merkleRoot1, proof) mintable(1) {
        require(whitelistMintCount[msg.sender] == 0, "You have already minted");
        whitelistMintCount[msg.sender] += 1;
        mint(1); 
    }
    
    function whitelist2Mint(uint256 amount, bytes32[] memory proof) public payable whiteList(merkleRoot2, proof) mintable(amount) {
        require(whitelistMintCount[msg.sender] + amount <=2, "You have already minted");
        whitelistMintCount[msg.sender] += amount;
        mint(amount);
    }
    
    function publicMint(uint256 amount) public payable mintable(amount) {
        require(saleStatus == SaleStatus.PUBLIC, "public sale currently unavailable.");
        require(amount <= maxPublicMintPerTx, "You can mint at most 20 times per transaction.");
        mint(amount);
    }
    
    function devMint(uint256 amount, address targetAddress) public onlyOwner {
        require(amount <= tokensRemaining);
        _mint(targetAddress, NINJALERT_NFT, amount, "");
        tokensRemaining -= amount;
    }
    
    function setURI(string memory uri_) public onlyOwner {
        _setURI(uri_);
    }
}

{
  "compilationTarget": {
    "contracts/NinjalertsLicense.sol": "NinjalertsLifetimeNFT"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}