// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.20;

import {IERC2981} from "../../interfaces/IERC2981.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 tokenId => RoyaltyInfo) private _tokenRoyaltyInfo;

    /**
     * @dev The default royalty set is invalid (eg. (numerator / denominator) >= 1).
     */
    error ERC2981InvalidDefaultRoyalty(uint256 numerator, uint256 denominator);

    /**
     * @dev The default royalty receiver is invalid.
     */
    error ERC2981InvalidDefaultRoyaltyReceiver(address receiver);

    /**
     * @dev The royalty set for an specific `tokenId` is invalid (eg. (numerator / denominator) >= 1).
     */
    error ERC2981InvalidTokenRoyalty(uint256 tokenId, uint256 numerator, uint256 denominator);

    /**
     * @dev The royalty receiver for `tokenId` is invalid.
     */
    error ERC2981InvalidTokenRoyaltyReceiver(uint256 tokenId, address receiver);

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        uint256 denominator = _feeDenominator();
        if (feeNumerator > denominator) {
            // Royalty fee will exceed the sale price
            revert ERC2981InvalidDefaultRoyalty(feeNumerator, denominator);
        }
        if (receiver == address(0)) {
            revert ERC2981InvalidDefaultRoyaltyReceiver(address(0));
        }

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual {
        uint256 denominator = _feeDenominator();
        if (feeNumerator > denominator) {
            // Royalty fee will exceed the sale price
            revert ERC2981InvalidTokenRoyalty(tokenId, feeNumerator, denominator);
        }
        if (receiver == address(0)) {
            revert ERC2981InvalidTokenRoyaltyReceiver(tokenId, address(0));
        }

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 indexed id);

    event Approval(address indexed owner, address indexed spender, uint256 indexed id);

    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /*//////////////////////////////////////////////////////////////
                         METADATA STORAGE/LOGIC
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    function tokenURI(uint256 id) public view virtual returns (string memory);

    /*//////////////////////////////////////////////////////////////
                      ERC721 BALANCE/OWNER STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) internal _ownerOf;

    mapping(address => uint256) internal _balanceOf;

    function ownerOf(uint256 id) public view virtual returns (address owner) {
        require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
    }

    function balanceOf(address owner) public view virtual returns (uint256) {
        require(owner != address(0), "ZERO_ADDRESS");

        return _balanceOf[owner];
    }

    /*//////////////////////////////////////////////////////////////
                         ERC721 APPROVAL STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) public getApproved;

    mapping(address => mapping(address => bool)) public isApprovedForAll;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
    }

    /*//////////////////////////////////////////////////////////////
                              ERC721 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 id) public virtual {
        address owner = _ownerOf[id];

        require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");

        getApproved[id] = spender;

        emit Approval(owner, spender, id);
    }

    function setApprovalForAll(address operator, bool approved) public virtual {
        isApprovedForAll[msg.sender][operator] = approved;

        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function transferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        require(from == _ownerOf[id], "WRONG_FROM");

        require(to != address(0), "INVALID_RECIPIENT");

        require(
            msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
            "NOT_AUTHORIZED"
        );

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        unchecked {
            _balanceOf[from]--;

            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        delete getApproved[id];

        emit Transfer(from, to, id);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    /*//////////////////////////////////////////////////////////////
                              ERC165 LOGIC
    //////////////////////////////////////////////////////////////*/

    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return
            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
            interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
            interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 id) internal virtual {
        require(to != address(0), "INVALID_RECIPIENT");

        require(_ownerOf[id] == address(0), "ALREADY_MINTED");

        // Counter overflow is incredibly unrealistic.
        unchecked {
            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        emit Transfer(address(0), to, id);
    }

    function _burn(uint256 id) internal virtual {
        address owner = _ownerOf[id];

        require(owner != address(0), "NOT_MINTED");

        // Ownership check above ensures no underflow.
        unchecked {
            _balanceOf[owner]--;
        }

        delete _ownerOf[id];

        delete getApproved[id];

        emit Transfer(owner, address(0), id);
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL SAFE MINT LOGIC
    //////////////////////////////////////////////////////////////*/

    function _safeMint(address to, uint256 id) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function _safeMint(
        address to,
        uint256 id,
        bytes memory data
    ) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }
}

/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721TokenReceiver.onERC721Received.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../utils/introspection/IERC165.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @notice Efficient library for creating string representations of integers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
library LibString {
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) return toString(uint256(value));

        unchecked {
            str = toString(uint256(-value));

            /// @solidity memory-safe-assembly
            assembly {
                // Note: This is only safe because we over-allocate memory
                // and write the string from right to left in toString(uint256),
                // and thus can be sure that sub(str, 1) is an unused memory location.

                let length := mload(str) // Load the string length.
                // Put the - character at the start of the string contents.
                mstore(str, 45) // 45 is the ASCII code for the - character.
                str := sub(str, 1) // Move back the string pointer by a byte.
                mstore(str, add(length, 1)) // Update the string length.
            }
        }
    }

    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
            // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
            // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
            let newFreeMemoryPointer := add(mload(0x40), 160)

            // Update the free memory pointer to avoid overriding our string.
            mstore(0x40, newFreeMemoryPointer)

            // Assign str to the end of the zone of newly allocated memory.
            str := sub(newFreeMemoryPointer, 32)

            // Clean the last word of memory it may not be overwritten.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                // Move the pointer 1 byte to the left.
                str := sub(str, 1)

                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))

                // Keep dividing temp until zero.
                temp := div(temp, 10)

                 // prettier-ignore
                if iszero(temp) { break }
            }

            // Compute and cache the final total length of the string.
            let length := sub(end, str)

            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 32)

            // Store the string's length at the start of memory allocated for our string.
            mstore(str, length)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @notice Gas optimized merkle proof verification library.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
library MerkleProofLib {
    function verify(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool isValid) {
        /// @solidity memory-safe-assembly
        assembly {
            if proof.length {
                // Left shifting by 5 is like multiplying by 32.
                let end := add(proof.offset, shl(5, proof.length))

                // Initialize offset to the offset of the proof in calldata.
                let offset := proof.offset

                // Iterate over proof elements to compute root hash.
                // prettier-ignore
                for {} 1 {} {
                    // Slot where the leaf should be put in scratch space. If
                    // leaf > calldataload(offset): slot 32, otherwise: slot 0.
                    let leafSlot := shl(5, gt(leaf, calldataload(offset)))

                    // Store elements to hash contiguously in scratch space.
                    // The xor puts calldataload(offset) in whichever slot leaf
                    // is not occupying, so 0 if leafSlot is 32, and 32 otherwise.
                    mstore(leafSlot, leaf)
                    mstore(xor(leafSlot, 32), calldataload(offset))

                    // Reuse leaf to store the hash to reduce stack operations.
                    leaf := keccak256(0, 64) // Hash both slots of scratch space.

                    offset := add(offset, 32) // Shift 1 word per cycle.

                    // prettier-ignore
                    if iszero(lt(offset, end)) { break }
                }
            }

            isValid := eq(leaf, root) // The proof is valid if the roots match.
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    uint256 private locked = 1;

    modifier nonReentrant() virtual {
        require(locked == 1, "REENTRANCY");

        locked = 2;

        _;

        locked = 1;
    }
}

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

// Workstation95
// https://workstation95.xyz

import {ERC721} from "solmate/tokens/ERC721.sol";
import {LibString} from "solmate/utils/LibString.sol";
import {MerkleProofLib} from "solmate/utils/MerkleProofLib.sol";
import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol";
import {Ownable} from "openzeppelin-contracts/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC2981} from "@openzeppelin/contracts/token/common/ERC2981.sol";

contract Workstation95 is ERC721, ERC2981, Ownable, ReentrancyGuard {
    uint256 public maxSupply;
    uint256 public totalSupply;
    uint256 public stdPrice;
    uint256 public discountPrice;
    uint256 public discountsPerCollection;
    uint256 public lastBulkMintedId = 1;

    string public baseURI;
    bool public isSaleActive = false;

    mapping(uint256 => uint256) public mintedBitmap;
    mapping(uint256 => uint256) public frameOnlyIdsBitmap;

    mapping(address => uint256) public discountedCredits;
    mapping(address => uint256) public stdCredits;
    mapping(address => uint256) public depositedEth;

    mapping(address => uint256) public claimedDiscounted;
    mapping(address => uint256) public claimedStd;
    mapping(address => uint256) public directPaidDiscounted;
    mapping(address => uint256) public directPaidStd;

    uint256 public totalDepositedUnspentETH;
    uint256 public totalClaimedCount;
    uint256 public ethTowardsMints;
    uint256 frameOnlyCount;

    bytes32 private merkleRoot;

    address public paymentsRecipient;

    // The many flavors of failure
    error MaxMintableLimitReached();
    error TokenIdOutOfRange();
    error TokenAlreadyMinted();
    error NoBalanceToWithdraw();
    error TransferFailed();
    error InsufficientBalance();
    error IncorrectEth(uint256 expected, uint256 received);
    error ShouldBeGreaterThanZero();
    error NotEnoughTokensAvailableToMint();
    error SaleNotActive();
    error Nope();
    error ExceedsAllowedDiscounts(uint256 allowed, uint256 requested);

    modifier saleActive() {
        if (!isSaleActive) {
            revert SaleNotActive();
        }
        _;
    }

    constructor(
        address initialOwner,
        address _paymentsRecipient,
        string memory _baseURI,
        uint256 _stdPrice,
        uint256 _discountPrice,
        uint256 _maxSupply,
        bytes32 _merkleRoot,
        uint256 _discountsPerCollection
    ) ERC721("Workstation95", "WS95") Ownable(initialOwner) {
        baseURI = _baseURI;
        stdPrice = _stdPrice;
        discountPrice = _discountPrice;
        maxSupply = _maxSupply;
        merkleRoot = _merkleRoot;
        discountsPerCollection = _discountsPerCollection;
        paymentsRecipient = _paymentsRecipient;
        _setDefaultRoyalty(_paymentsRecipient, 1000);
    }

    /**
     * @notice Allows a user to deposit Ether to purchase credits (discounted and standard).
     * @dev The function verifies the user's collection presence count (how many collections they hold) and merkle proof to determine the available discounts they're eligible for.
     * @param collectionPresenceCount The number of collections the user holds.
     * @param merkleProof The merkle proof to verify the user's collection holdings.
     * @param depositedDiscountQty The quantity of discounted credits being purchased.
     * @param depositedStdQty The quantity of standard credits being purchased.
     */
    function deposit(uint256 collectionPresenceCount, bytes32[] calldata merkleProof, uint256 depositedDiscountQty, uint256 depositedStdQty) public saleActive payable {
        if (msg.value == 0) {
            revert ShouldBeGreaterThanZero();
        }

        uint256 availableDiscounts = availableDiscountQuantity(msg.sender, collectionPresenceCount, merkleProof);
        if (depositedDiscountQty > availableDiscounts) {
            revert ExceedsAllowedDiscounts(availableDiscounts, depositedDiscountQty);
        }

        if (msg.value != (depositedDiscountQty * discountPrice) + (depositedStdQty * stdPrice)) {
            revert IncorrectEth((depositedDiscountQty * discountPrice) + (depositedStdQty * stdPrice), msg.value);
        }

        discountedCredits[msg.sender] += depositedDiscountQty;
        stdCredits[msg.sender] += depositedStdQty;
        depositedEth[msg.sender] += msg.value;
        totalDepositedUnspentETH += msg.value;
    }

    /**
     * @notice Allows a user to withdraw their deposited but unused balance.
     */
    function withdrawBalance() nonReentrant public {

        uint256 spentAmount = calcSpentDeposits(msg.sender);

        uint amount = depositedEth[msg.sender] - spentAmount;

        if (amount == 0) {
            revert NoBalanceToWithdraw();
        }

        discountedCredits[msg.sender] = 0;
        stdCredits[msg.sender] = 0;
        depositedEth[msg.sender] -= amount;
        totalDepositedUnspentETH -= amount;

        (bool success, ) = msg.sender.call{value: amount}("");
        if (!success) {
            revert TransferFailed();
        }
    }

    /**
     * @notice Calculates the remaining available discount quantity for a user.
     * @dev This function is intended to be called from the frontend for UI purposes.
     * It verifies the user's collection presence count using the provided Merkle proof.
     * If the verification passes, it returns the number of discounts the user has left AFTER subtracting the claimed and directly paid discounts.
     * Does not count pending but un-spent discount credits, that can be calculated as needed elsewhere.
     * If the verification fails, it returns zero.
     * @param addr The address of the user.
     * @param collectionPresenceCount The number of collections the user is present in, as determined by the backend.
     * @param merkleProof The Merkle proof to verify the user's collection presence count.
     * @return The available discount quantity for the user.
     * - If the Merkle proof verification passes, it returns the calculated available discount quantity.
     * - If the Merkle proof verification fails, it returns zero.
     */
    function availableDiscountQuantity(address addr, uint256 collectionPresenceCount, bytes32[] calldata merkleProof) public view returns (uint256) {
        bytes32 leaf = keccak256(abi.encodePacked(addr, collectionPresenceCount));
        if (MerkleProofLib.verify(merkleProof, merkleRoot, leaf)) {
            return (collectionPresenceCount * discountsPerCollection) - claimedDiscounted[addr] - directPaidDiscounted[addr];
        } else {
            return 0;
        }
    }

    /**
     * @notice Calculates the eligible discount quantity for a user based on their collection presence count and Merkle proof.
     * @dev This function verifies the user's collection presence count using the provided Merkle proof.
     * @param addr The address of the user.
     * @param collectionPresenceCount The number of collections the user is present in.
     * @param merkleProof The Merkle proof to verify the user's collection presence count.
     * @return The eligible discount quantity for the user.
     * - If the Merkle proof verification passes, it returns the calculated eligible discount quantity.
     * - If the Merkle proof verification fails, it returns zero.
     */
    function eligibleDiscountQuantity(address addr, uint256 collectionPresenceCount, bytes32[] calldata merkleProof) public view returns (uint256) {
        bytes32 leaf = keccak256(abi.encodePacked(addr, collectionPresenceCount));
        if (MerkleProofLib.verify(merkleProof, merkleRoot, leaf)) {
            return (collectionPresenceCount * discountsPerCollection);
        } else {
            return 0;
        }
    }

    /**
     * @notice Returns the total eligible and available discount quantities for a user.
     * @dev This is a convenience function for the front end to retrieve both the total eligible and available discount quantities in a single call.
     * @param addr The address of the user.
     * @param collectionPresenceCount The number of collections the user is present in.
     * @param merkleProof The merkle proof to verify the user's collection presence count.
     * @return total The total eligible discount quantity for the user.
     * @return available The available discount quantity for the user.
     */
    function discountQuantities(address addr, uint256 collectionPresenceCount, bytes32[] calldata merkleProof) public view returns (uint256 total, uint256 available) {
        total = eligibleDiscountQuantity(addr, collectionPresenceCount, merkleProof);
        available = availableDiscountQuantity(addr, collectionPresenceCount, merkleProof);
        return (total, available);
    }

    /**
     * @notice Returns the total active, unclaimed credits (discounted + standard) for a user.
     * @param addr The address of the user.
     * @return The total active credits for the user.
     */
    function totalActiveCredits(address addr) public view returns (uint256) {
        return discountedCredits[addr] + stdCredits[addr];
    }

    function setMerkleRoot(bytes32 root) external onlyOwner {
        merkleRoot = root;
    }

    function updateMaxSupply(uint newMaxSupply) external onlyOwner {
        maxSupply = newMaxSupply;
    }

    function updateBaseUri(string memory newBaseUri) external onlyOwner {
        baseURI = newBaseUri;
    }

    function toggleSale() external onlyOwner {
        isSaleActive = !isSaleActive;
    }

    /**
     * @notice Checks if a token with the given ID has been minted.
     * @param tokenId The ID of the token to check.
     * @return A boolean value indicating whether the token has been minted.
     */
    function isMinted(uint tokenId) public view returns (bool) {
        if(tokenId < 1 || tokenId > maxSupply) {
            return false;
        }
        uint256 index = tokenId / 256;
        uint256 position = tokenId % 256;
        uint256 flag = (mintedBitmap[index] >> position) & uint256(1);
        return flag == 1;
    }

    /**
     * @notice Checks if a token ID is designated as a Frame-only image.
     * @param tokenId The ID of the token to check.
     * @return A boolean value indicating whether the token ID is a Frame-only ID.
     */
    function isFrameOnlyId(uint tokenId) public view returns (bool) {
        if(tokenId < 1 || tokenId > maxSupply) {
            return false;
        }
        uint256 index = tokenId / 256;
        uint256 position = tokenId % 256;
        uint256 flag = (frameOnlyIdsBitmap[index] >> position) & uint256(1);
        return flag == 1;
    }

    function initializeFrameOnlyIds(uint256[] calldata frameOnlyIds) external onlyOwner {
        for (uint i = 0; i < frameOnlyIds.length; i++) {
            setFrameOnlyId(frameOnlyIds[i]);
        }
        frameOnlyCount = frameOnlyIds.length;
    }

    function setFrameOnlyCount(uint256 count) external onlyOwner {
        frameOnlyCount = count;
    }

    function withdrawTeamBalance() public {
        if (ethTowardsMints == 0) {
            revert NoBalanceToWithdraw();
        }

        (bool success, ) = payable(paymentsRecipient).call{value: ethTowardsMints}("");
        if (!success) {
            revert TransferFailed();
        }
        ethTowardsMints = 0;
    }

    /**
     * @notice Mints a specific token ID on behalf of another wallet, assuming they have sufficient credit.
     * @dev This function allows the contract owner to mint a token with a specific ID for a receiver address.
     * Intended for use by the Frame backend.
     * @param receiver The address of the wallet receiving the minted token.
     * @param tokenId The ID of the token to be minted.
     **/
    function mint(address receiver, uint tokenId) public saleActive onlyOwner {
        if (totalSupply + 1 > maxSupply) {
            revert MaxMintableLimitReached();
        }
        if(tokenId < 1 || tokenId > maxSupply) {
            revert TokenIdOutOfRange();
        }

        if (isMinted(tokenId)) {
            revert TokenAlreadyMinted();
        }

        // First see if discountedCredits are available
        if (discountedCredits[receiver] > 0) {
            discountedCredits[receiver]--;
            claimedDiscounted[receiver]++;
            ethTowardsMints += discountPrice;
            totalDepositedUnspentETH -= discountPrice;
        } else if (stdCredits[receiver] > 0) {
            stdCredits[receiver]--;
            claimedStd[receiver]++;
            ethTowardsMints += stdPrice;
            totalDepositedUnspentETH -= stdPrice;
        } else {
            revert InsufficientBalance();
        }

        totalClaimedCount++;
        _mintToken(receiver, tokenId);
    }

    /**
     * @notice Calculates the amount of Ether spent by a user via deposit claims, excluding direct payments.
     * @param addr The address of the user.
     * @return The total amount of Ether spent by the user via deposit claims.
     */
    function calcSpentDeposits(address addr) public view returns (uint256) {
        return (claimedDiscounted[addr] * discountPrice) + (claimedStd[addr] * stdPrice);
    }

    function setRoyalty(
        address receiver,
        uint96 feeNumerator
    ) external onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    /**
     * @notice Mints multiple tokens by quantity for the sender, allowing a combination of discounted and standard prices.    
     * @param quantity The total quantity of tokens to mint.
     * @param collectionPresenceCount The number of collections the sender is present in.
     * @param merkleProof The Merkle proof to verify the sender's collection presence count.
     * @param discountQty The quantity of tokens to mint using discounted credits.
     * @param stdQty The quantity of tokens to mint using standard credits.
     */
    function mintMultipleByQuantity(
        uint quantity,
        uint256 collectionPresenceCount,
        bytes32[] calldata merkleProof,
        uint256 discountQty, 
        uint256 stdQty
        ) public payable saleActive {

        if (quantity == 0) {
            revert ShouldBeGreaterThanZero();
        }

        if (totalSupply + quantity > maxSupply - frameOnlyCount) {
            revert MaxMintableLimitReached();
        }

        if(discountQty + stdQty != quantity){
            revert Nope();
        }

        // Make sure they're not sending in more discount priced eth than they have available.
        // This takes into consideration the amount of discounted mints they've actually made AND any deposited discounts, which we'll treat like a mint here.
        // Otherwise have a situation where, e.g, you are allowed 2 discounted, and you deposit 1 for a discount, then try to mint 2 discounted and 1 standard.
        // Then what happens with that deposited discount? If you're all allocated up it's stuck.
        uint256 rawAvailDiscounts = availableDiscountQuantity(msg.sender, collectionPresenceCount, merkleProof);
        uint256 availableDiscounts = rawAvailDiscounts > 0 ? rawAvailDiscounts - discountedCredits[msg.sender] : 0;
        
        if (discountQty > availableDiscounts) {
            revert ExceedsAllowedDiscounts(availableDiscounts, discountQty);
        }

        if (msg.value != (discountQty * discountPrice) + (stdQty * stdPrice)) {
            revert IncorrectEth((discountQty * discountPrice) + (stdQty * stdPrice), msg.value);
        }        
        
        ethTowardsMints += msg.value;

        directPaidDiscounted[msg.sender] = directPaidDiscounted[msg.sender] + discountQty;
        directPaidStd[msg.sender] = directPaidStd[msg.sender] + stdQty;
  
        uint256 tokensMinted = 0;
        uint256 maxId;
        
        for (uint256 i = lastBulkMintedId; tokensMinted < quantity && i <= maxSupply; i++) {
            if (!isMinted(i) && !isFrameOnlyId(i)) {
                maxId = i;
                tokensMinted++;
                _mintToken(msg.sender, i);
            }
        }
        
        lastBulkMintedId = maxId;

        if (tokensMinted != quantity) {
            revert NotEnoughTokensAvailableToMint();
        }
    }

    function tokenURI(
        uint256 tokenId
    ) public view override returns (string memory) {
        require(
            isMinted(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );        
        return string(abi.encodePacked(baseURI, LibString.toString(tokenId), ".json"));
    }

    function _mintToken(address receiver, uint tokenId) private {
        uint256 index = tokenId / 256;
        uint256 position = tokenId % 256;
        mintedBitmap[index] = mintedBitmap[index] | (uint256(1) << position);

        totalSupply++;
        _mint(receiver, tokenId);
    }

    function setFrameOnlyId(uint256 tokenId) public onlyOwner {
        uint256 index = tokenId / 256;
        uint256 position = tokenId % 256;
        frameOnlyIdsBitmap[index] = frameOnlyIdsBitmap[index] | (uint256(1) << position);
    }

    function withdrawToken(
        address tokenAddress,
        uint256 amount
    ) external {
        require(
            IERC20(tokenAddress).transfer(paymentsRecipient, amount),
            "Transfer failed"
        );
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC721, ERC2981) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    receive() external payable {
        ethTowardsMints += msg.value;
    }
}

{
  "compilationTarget": {
    "src/Workstation95.sol": "Workstation95"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/=node_modules/@openzeppelin/",
    ":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    ":ERC721A/=lib/ERC721A/contracts/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/",
    ":solmate/=lib/solmate/src/"
  ]
}