OGTriple Certification

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.27;

import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";

contract Access is AccessControl {
    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
    }

    function batchGrantRole(bytes32 role, address[] calldata accounts)
        external
        onlyRole(getRoleAdmin(role))
        returns (bool[] memory)
    {
        uint256 length = accounts.length;
        bool[] memory results = new bool[](length);

        for (uint256 i = 0; i < length; ++i) {
            results[i] = _grantRole(role, accounts[i]);
        }

        return results;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.27;

import {ERC721, ERC721Royalty} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Access} from "./Access.sol";

contract OGTCertification is ERC721Royalty, Ownable {
    Access public access;
    uint256 private _nextTokenId = 1;
    uint256 public maxSupply;
    bytes32 public stageRole;
    uint256 public stageStart;
    uint256 public stageFinish;
    string private _baseUriValue;
    mapping(address => bool) public hasMinted;

    bytes32 public constant ANY = keccak256("ANY");

    event StageSet(bytes32 indexed stageRole, uint256 stageStart, uint256 stageFinish);
    event BaseURISet(string newBaseURI);
    event AccessSet(address indexed newAccessAddress);
    event TokenRoyaltySet(uint256 indexed tokenId, address indexed receiver, uint96 feeNumerator);

    constructor(
        address initialOwner,
        address accessAddress,
        uint256 _maxSupply,
        string memory _uri,
        address royaltyReceiver,
        uint96 royaltyFeeNumerator
    ) ERC721("OGT", "OGT") Ownable(initialOwner) {
        access = Access(accessAddress);
        maxSupply = _maxSupply;
        _baseUriValue = _uri;
        _setDefaultRoyalty(royaltyReceiver, royaltyFeeNumerator);
    }

    function setStage(bytes32 _stageRole, uint256 _stageStart, uint256 _stageFinish) external {
        require(access.hasRole(access.DEFAULT_ADMIN_ROLE(), _msgSender()), "Not allowed");
        stageRole = _stageRole;
        stageStart = _stageStart;
        stageFinish = _stageFinish;
        emit StageSet(stageRole, stageStart, stageFinish);
    }

    function safeMint() external {
        address to = _msgSender();
        require(!hasMinted[to], "Address has already minted a token");
        require(_nextTokenId <= maxSupply, "Maximum supply reached");
        require(block.timestamp >= stageStart, "Stage has not started yet");
        require(block.timestamp <= stageFinish, "Stage has finished");

        if (stageRole != ANY) {
            require(stageRole != bytes32(0) && access.hasRole(stageRole, to), "Not allowed");
        }

        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        hasMinted[to] = true;
    }

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

    function getBaseURI() external view onlyOwner returns (string memory) {
        return _baseURI();
    }

    function setBaseURI(string memory _newBaseURI) external onlyOwner {
        _baseUriValue = _newBaseURI;
        emit BaseURISet(_newBaseURI);
    }

    function setAccess(address _newAccessAddress) external onlyOwner {
        require(_newAccessAddress != address(0), "New access control contract address cannot be the zero address.");
        access = Access(_newAccessAddress);
        emit AccessSet(_newAccessAddress);
    }

    function setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) external onlyOwner {
        require(receiver != address(0), "Invalid receiver.");
        require(feeNumerator > 0, "Fee must be > 0.");
        _setTokenRoyalty(tokenId, receiver, feeNumerator);
        emit TokenRoyaltySet(tokenId, receiver, feeNumerator);
    }
}

{
  "compilationTarget": {
    "src/OGTCertification.sol": "OGTCertification"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/=../node_modules/@openzeppelin/",
    ":forge-std/=../node_modules/forge-std/"
  ]
}