RabbitHoleTickets.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.19;

import {Ownable} from "solady/auth/Ownable.sol";
import {ERC1155} from "solady/tokens/ERC1155.sol";
import {Base64} from "solady/utils/Base64.sol";
import {Initializable} from "openzeppelin-contracts-upgradeable/proxy/utils/Initializable.sol";
import {
    IERC165Upgradeable,
    IERC2981Upgradeable
} from "openzeppelin-contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";

contract RabbitHoleTickets is Initializable, Ownable, ERC1155, IERC2981Upgradeable {
    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/
    error OnlyMinter();

    event RoyaltyFeeSet(uint256 indexed royaltyFee);
    event MinterAddressSet(address indexed minterAddress);

    /*//////////////////////////////////////////////////////////////
                                STORAGE
    //////////////////////////////////////////////////////////////*/
    address public royaltyRecipient;
    address public minterAddress;
    uint256 public royaltyFee;
    string public imageIPFSCID;
    string public animationUrlIPFSCID;
    // insert new vars here at the end to keep the storage layout the same

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/
    /// @custom:oz-upgrades-unsafe-allow constructor
    // solhint-disable-next-line func-visibility
    constructor() {
        _disableInitializers();
    }

    function initialize(
        address royaltyRecipient_,
        address minterAddress_,
        uint256 royaltyFee_,
        address owner_,
        string memory imageIPFSCID_,
        string memory animationUrlIPFSCID_
    ) external initializer {
        _initializeOwner(owner_);
        royaltyRecipient = royaltyRecipient_;
        minterAddress = minterAddress_;
        royaltyFee = royaltyFee_;
        imageIPFSCID = imageIPFSCID_;
        animationUrlIPFSCID = animationUrlIPFSCID_;
    }

    /*//////////////////////////////////////////////////////////////
                               MODIFIERS
    //////////////////////////////////////////////////////////////*/
    modifier onlyMinter() {
        if (msg.sender != minterAddress) revert OnlyMinter();
        _;
    }

    /*//////////////////////////////////////////////////////////////
                            EXTERNAL UPDATE
    //////////////////////////////////////////////////////////////*/

    /*//////////////////////////////////////////////////////////////
                                  MINT
    //////////////////////////////////////////////////////////////*/
    /// @dev mint a single ticket, only callable by the allowed minter
    /// @param to_ the address to mint the ticket to
    /// @param id_ the id of the ticket to mint
    /// @param amount_ the amount of the ticket to mint
    /// @param data_ the data to pass to the mint function
    function mint(address to_, uint256 id_, uint256 amount_, bytes memory data_) external onlyMinter {
        _mint(to_, id_, amount_, data_);
    }

    /// @dev mint a batch of tickets, only callable by the allowed minter
    /// @param to_ the address to mint the tickets to
    /// @param ids_ the ids of the tickets to mint
    /// @param amounts_ the amounts of the tickets to mint
    /// @param data_ the data to pass to the mint function
    function mintBatch(
        address to_,
        uint256[] memory ids_,
        uint256[] memory amounts_,
        bytes memory data_
    ) external onlyMinter {
        _batchMint(to_, ids_, amounts_, data_);
    }

    /*//////////////////////////////////////////////////////////////
                                  SET
    //////////////////////////////////////////////////////////////*/
    /// @dev set the animation url IPFS CID
    /// @param animationUrlIPFSCID_ the animation url IPFS CID
    function setAnimationUrlIPFSCID(string memory animationUrlIPFSCID_) external onlyOwner {
        animationUrlIPFSCID = animationUrlIPFSCID_;
    }

    /// @dev set the image IPFS CID
    /// @param imageIPFSCID_ the image IPFS CID
    function setImageIPFSCID(string memory imageIPFSCID_) external onlyOwner {
        imageIPFSCID = imageIPFSCID_;
    }

    /// @dev set the minter address
    /// @param minterAddress_ the address of the minter
    function setMinterAddress(address minterAddress_) external onlyOwner {
        minterAddress = minterAddress_;
        emit MinterAddressSet(minterAddress_);
    }

    /// @dev set the royalty fee
    /// @param royaltyFee_ the royalty fee
    function setRoyaltyFee(uint256 royaltyFee_) external onlyOwner {
        royaltyFee = royaltyFee_;
        emit RoyaltyFeeSet(royaltyFee_);
    }

    /// @dev set the royalty recipient
    /// @param royaltyRecipient_ the address of the royalty recipient
    function setRoyaltyRecipient(address royaltyRecipient_) external onlyOwner {
        royaltyRecipient = royaltyRecipient_;
    }

    /*//////////////////////////////////////////////////////////////
                             EXTERNAL VIEW
    //////////////////////////////////////////////////////////////*/

    /// @dev See {IERC165-royaltyInfo}
    /// @param salePrice_ the sale price
    function royaltyInfo(
        uint256,
        uint256 salePrice_
    ) external view override returns (address receiver, uint256 royaltyAmount) {
        uint256 royaltyPayment = (salePrice_ * royaltyFee) / 10_000;
        return (royaltyRecipient, royaltyPayment);
    }

    /// @dev returns true if the supplied interface id is supported
    /// @param interfaceId_ the interface id
    function supportsInterface(bytes4 interfaceId_)
        public
        view
        virtual
        override (ERC1155, IERC165Upgradeable)
        returns (bool)
    {
        return interfaceId_ == type(IERC2981Upgradeable).interfaceId || super.supportsInterface(interfaceId_);
    }

    /// @dev returns the token uri
    function uri(uint256 tokenId_) public view override (ERC1155) returns (string memory) {
        bytes memory dataURI = generateDataURI(tokenId_);
        return string(abi.encodePacked("data:application/json;base64,", Base64.encode(dataURI)));
    }

    /*//////////////////////////////////////////////////////////////
                             INTERNAL VIEW
    //////////////////////////////////////////////////////////////*/

    /// @dev returns the data uri in json format
    function generateDataURI(uint256 tokenId_) internal view virtual returns (bytes memory) {
        // solhint-disable quotes
        bytes memory dataURI = abi.encodePacked(
            "{",
            '"name": "',
            getNameForToken(tokenId_),
            '",',
            '"description": "',
            getDescriptionForToken(tokenId_),
            '",',
            '"image": "',
            makeIPFSUrl(getImageCidForToken(tokenId_)),
            '",',
            '"animation_url": "',
            makeIPFSUrl(getAnimationCidForToken(tokenId_)),
            '"',
            "}"
        );
        // solhint-enable quotes
        return dataURI;
    }

    function getNameForToken(uint256 tokenId_) internal view virtual returns (string memory) {
        if(tokenId_ == 2) {
            return "2023 RabbitHole Holiday Reward";
        } else {
            return "RabbitHole Ticket";
        }
    }

    function getDescriptionForToken(uint256 tokenId_) internal view virtual returns (string memory) {
        if(tokenId_ == 2) {
            return "You unwrapped a Christmas gift from RabbitHole for being a loyal member and completing our 2023 Holiday campaign";
        } else {
            return "RabbitHole Tickets";
        }
    }

    function getAnimationCidForToken(uint256 tokenId_) internal view virtual returns (string memory) {
        if(tokenId_ == 2) {
            return "bafybeig7sfklww3qsd2yah4tottv6ewvroad5cqidvxswtdrblzvd7gf64";
        } else {
            return animationUrlIPFSCID;
        }
    }

    function getImageCidForToken(uint256 tokenId_) internal view virtual returns (string memory) {
        if(tokenId_ == 2) {
            return "bafybeigoo4rnwlmeyyq2rgcteqb3srxaida24jpiedxsoqa7cvpbjhnzni";
        } else {
            return imageIPFSCID;
        }
    }

    function makeIPFSUrl(string memory ipfsCid_) internal view virtual returns (string memory) {
        if (bytes(ipfsCid_).length == 0) {
            return "";
        }
        return string(abi.encodePacked("ipfs://", ipfsCid_));
    }
}