@artblocks/contracts 0.0.1 → 1.0.0

package/contracts/minter-suite/Minters/MinterMerkleV5.sol

@@ -0,0 +1,688 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../../interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "../../interfaces/0.8.x/IMinterFilterV0.sol";
+import "../../interfaces/0.8.x/IFilteredMinterMerkleV2.sol";
+import "../../interfaces/0.8.x/IDelegationRegistry.sol";
+import "./MinterBase_v0_1_1.sol";
+
+import "@openzeppelin-4.7/contracts/utils/cryptography/MerkleProof.sol";
+import "@openzeppelin-4.7/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin-4.7/contracts/security/ReentrancyGuard.sol";
+
+pragma solidity 0.8.17;
+
+/**
+ * @title Filtered Minter contract that allows tokens to be minted with ETH
+ * for addresses in a Merkle allowlist.
+ * This is designed to be used with GenArt721CoreContractV3 flagship or
+ * engine contracts.
+ * @author Art Blocks Inc.
+ * @notice Privileged Roles and Ownership:
+ * This contract is designed to be managed, with limited powers.
+ * Privileged roles and abilities are controlled by the project's artist, which
+ * can be modified by the core contract's Admin ACL contract. Both of these
+ * roles hold extensive power and can modify minter details.
+ * Care must be taken to ensure that the admin ACL contract and artist
+ * addresses are secure behind a multi-sig or other access control mechanism.
+ * ----------------------------------------------------------------------------
+ * The following functions are restricted to a project's artist:
+ * - updateMerkleRoot
+ * - updatePricePerTokenInWei
+ * - setProjectInvocationsPerAddress
+ * - setProjectMaxInvocations
+ * - manuallyLimitProjectMaxInvocations
+ * ----------------------------------------------------------------------------
+ * Additional admin and artist privileged roles may be described on other
+ * contracts that this minter integrates with.
+ * ----------------------------------------------------------------------------
+ * This contract allows vaults to configure token-level or wallet-level
+ * delegation of minting privileges. This allows a vault on an allowlist to
+ * delegate minting privileges to a wallet that is not on the allowlist,
+ * enabling the vault to remain air-gapped while still allowing minting. The
+ * delegation registry contract is responsible for managing these delegations,
+ * and is available at the address returned by the public immutable
+ * `delegationRegistryAddress`. At the time of writing, the delegation
+ * registry enables easy delegation configuring at https://delegate.cash/.
+ * Art Blocks does not guarentee the security of the delegation registry, and
+ * users should take care to ensure that the delegation registry is secure.
+ * Token-level delegations are configured by the vault owner, and contract-
+ * level delegations must be configured for the core token contract as returned
+ * by the public immutable variable `genArt721CoreAddress`.
+ */
+contract MinterMerkleV5 is
+    ReentrancyGuard,
+    MinterBase,
+    IFilteredMinterMerkleV2
+{
+    using MerkleProof for bytes32[];
+
+    /// Delegation registry address
+    address public immutable delegationRegistryAddress;
+
+    /// Delegation registry address
+    IDelegationRegistry private immutable delegationRegistryContract;
+
+    /// Core contract address this minter interacts with
+    address public immutable genArt721CoreAddress;
+
+    /// The core contract integrates with V3 contracts
+    IGenArt721CoreContractV3_Base private immutable genArtCoreContract_Base;
+
+    /// Minter filter address this minter interacts with
+    address public immutable minterFilterAddress;
+
+    /// Minter filter this minter may interact with.
+    IMinterFilterV0 private immutable minterFilter;
+
+    /// minterType for this minter
+    string public constant minterType = "MinterMerkleV5";
+
+    /// project minter configuration keys used by this minter
+    bytes32 private constant CONFIG_MERKLE_ROOT = "merkleRoot";
+    bytes32 private constant CONFIG_USE_MAX_INVOCATIONS_PER_ADDRESS_OVERRIDE =
+        "useMaxMintsPerAddrOverride"; // shortened to fit in 32 bytes
+    bytes32 private constant CONFIG_MAX_INVOCATIONS_OVERRIDE =
+        "maxMintsPerAddrOverride"; // shortened to match format of previous key
+
+    uint256 constant ONE_MILLION = 1_000_000;
+
+    uint256 public constant DEFAULT_MAX_INVOCATIONS_PER_ADDRESS = 1;
+
+    struct ProjectConfig {
+        bool maxHasBeenInvoked;
+        bool priceIsConfigured;
+        // initial value is false, so by default, projects limit allowlisted
+        // addresses to a mint qty of `DEFAULT_MAX_INVOCATIONS_PER_ADDRESS`
+        bool useMaxInvocationsPerAddressOverride;
+        // a value of 0 means no limit
+        // (only used if `useMaxInvocationsPerAddressOverride` is true)
+        uint24 maxInvocationsPerAddressOverride;
+        uint24 maxInvocations;
+        uint256 pricePerTokenInWei;
+    }
+
+    mapping(uint256 => ProjectConfig) public projectConfig;
+
+    /// projectId => merkle root
+    mapping(uint256 => bytes32) public projectMerkleRoot;
+
+    /// projectId => purchaser address => qty of mints purchased for project
+    mapping(uint256 => mapping(address => uint256))
+        public projectUserMintInvocations;
+
+    modifier onlyArtist(uint256 _projectId) {
+        require(
+            msg.sender ==
+                genArtCoreContract_Base.projectIdToArtistAddress(_projectId),
+            "Only Artist"
+        );
+        _;
+    }
+
+    /**
+     * @notice Initializes contract to be a Filtered Minter for
+     * `_minterFilter`, integrated with Art Blocks core contract
+     * at address `_genArt721Address`. Also configures the delegation
+     * registry address to be address `_delegationRegistryAddress`.
+     * @param _genArt721Address Art Blocks core contract address for
+     * which this contract will be a minter.
+     * @param _minterFilter Minter filter for which this will be a
+     * filtered minter.
+     * @param _delegationRegistryAddress Delegation registry contract address.
+     */
+    constructor(
+        address _genArt721Address,
+        address _minterFilter,
+        address _delegationRegistryAddress
+    ) ReentrancyGuard() MinterBase(_genArt721Address) {
+        genArt721CoreAddress = _genArt721Address;
+        // always populate immutable engine contracts, but only use appropriate
+        // interface based on isEngine in the rest of the contract
+        genArtCoreContract_Base = IGenArt721CoreContractV3_Base(
+            _genArt721Address
+        );
+        delegationRegistryAddress = _delegationRegistryAddress;
+        emit DelegationRegistryUpdated(_delegationRegistryAddress);
+        delegationRegistryContract = IDelegationRegistry(
+            _delegationRegistryAddress
+        );
+        minterFilterAddress = _minterFilter;
+        minterFilter = IMinterFilterV0(_minterFilter);
+        require(
+            minterFilter.genArt721CoreAddress() == _genArt721Address,
+            "Illegal contract pairing"
+        );
+        // broadcast default max invocations per address for this minter
+        emit DefaultMaxInvocationsPerAddress(
+            DEFAULT_MAX_INVOCATIONS_PER_ADDRESS
+        );
+    }
+
+    /**
+     * @notice Update the Merkle root for project `_projectId`.
+     * @param _projectId Project ID to be updated.
+     * @param _root root of Merkle tree defining addresses allowed to mint
+     * on project `_projectId`.
+     */
+    function updateMerkleRoot(
+        uint256 _projectId,
+        bytes32 _root
+    ) external onlyArtist(_projectId) {
+        require(_root != bytes32(0), "Root must be provided");
+        projectMerkleRoot[_projectId] = _root;
+        emit ConfigValueSet(_projectId, CONFIG_MERKLE_ROOT, _root);
+    }
+
+    /**
+     * @notice Returns hashed address (to be used as merkle tree leaf).
+     * Included as a public function to enable users to calculate their hashed
+     * address in Solidity when generating proofs off-chain.
+     * @param _address address to be hashed
+     * @return bytes32 hashed address, via keccak256 (using encodePacked)
+     */
+    function hashAddress(address _address) public pure returns (bytes32) {
+        return keccak256(abi.encodePacked(_address));
+    }
+
+    /**
+     * @notice Verify if address is allowed to mint on project `_projectId`.
+     * @param _projectId Project ID to be checked.
+     * @param _proof Merkle proof for address.
+     * @param _address Address to check.
+     * @return inAllowlist true only if address is allowed to mint and valid
+     * Merkle proof was provided
+     */
+    function verifyAddress(
+        uint256 _projectId,
+        bytes32[] calldata _proof,
+        address _address
+    ) public view returns (bool) {
+        return
+            _proof.verifyCalldata(
+                projectMerkleRoot[_projectId],
+                hashAddress(_address)
+            );
+    }
+
+    /**
+     * @notice Sets maximum allowed invocations per allowlisted address for
+     * project `_project` to `limit`. If `limit` is set to 0, allowlisted
+     * addresses will be able to mint as many times as desired, until the
+     * project reaches its maximum invocations.
+     * Default is a value of 1 if never configured by artist.
+     * @param _projectId Project ID to toggle the mint limit.
+     * @param _maxInvocationsPerAddress Maximum allowed invocations per
+     * allowlisted address.
+     * @dev default value stated above must be updated if the value of
+     * CONFIG_USE_MAX_INVOCATIONS_PER_ADDRESS_OVERRIDE is changed.
+     */
+    function setProjectInvocationsPerAddress(
+        uint256 _projectId,
+        uint24 _maxInvocationsPerAddress
+    ) external onlyArtist(_projectId) {
+        ProjectConfig storage _projectConfig = projectConfig[_projectId];
+        // use override value instead of the contract's default
+        // @dev this never changes from true to false; default value is only
+        // used if artist has never configured project invocations per address
+        _projectConfig.useMaxInvocationsPerAddressOverride = true;
+        // update the override value
+        _projectConfig
+            .maxInvocationsPerAddressOverride = _maxInvocationsPerAddress;
+        // generic events
+        emit ConfigValueSet(
+            _projectId,
+            CONFIG_USE_MAX_INVOCATIONS_PER_ADDRESS_OVERRIDE,
+            true
+        );
+        emit ConfigValueSet(
+            _projectId,
+            CONFIG_MAX_INVOCATIONS_OVERRIDE,
+            uint256(_maxInvocationsPerAddress)
+        );
+    }
+
+    /**
+     * @notice Syncs local maximum invocations of project `_projectId` based on
+     * the value currently defined in the core contract.
+     * @param _projectId Project ID to set the maximum invocations for.
+     * @dev this enables gas reduction after maxInvocations have been reached -
+     * core contracts shall still enforce a maxInvocation check during mint.
+     */
+    function setProjectMaxInvocations(
+        uint256 _projectId
+    ) external onlyArtist(_projectId) {
+        uint256 maxInvocations;
+        uint256 invocations;
+        (invocations, maxInvocations, , , , ) = genArtCoreContract_Base
+            .projectStateData(_projectId);
+        // update storage with results
+        projectConfig[_projectId].maxInvocations = uint24(maxInvocations);
+
+        // We need to ensure maxHasBeenInvoked is correctly set after manually syncing the
+        // local maxInvocations value with the core contract's maxInvocations value.
+        // This synced value of maxInvocations from the core contract will always be greater
+        // than or equal to the previous value of maxInvocations stored locally.
+        projectConfig[_projectId].maxHasBeenInvoked =
+            invocations == maxInvocations;
+
+        emit ProjectMaxInvocationsLimitUpdated(_projectId, maxInvocations);
+    }
+
+    /**
+     * @notice Manually sets the local maximum invocations of project `_projectId`
+     * with the provided `_maxInvocations`, checking that `_maxInvocations` is less
+     * than or equal to the value of project `_project_id`'s maximum invocations that is
+     * set on the core contract.
+     * @dev Note that a `_maxInvocations` of 0 can only be set if the current `invocations`
+     * value is also 0 and this would also set `maxHasBeenInvoked` to true, correctly short-circuiting
+     * this minter's purchase function, avoiding extra gas costs from the core contract's maxInvocations check.
+     * @param _projectId Project ID to set the maximum invocations for.
+     * @param _maxInvocations Maximum invocations to set for the project.
+     */
+    function manuallyLimitProjectMaxInvocations(
+        uint256 _projectId,
+        uint256 _maxInvocations
+    ) external onlyArtist(_projectId) {
+        // CHECKS
+        // ensure that the manually set maxInvocations is not greater than what is set on the core contract
+        uint256 maxInvocations;
+        uint256 invocations;
+        (invocations, maxInvocations, , , , ) = genArtCoreContract_Base
+            .projectStateData(_projectId);
+        require(
+            _maxInvocations <= maxInvocations,
+            "Cannot increase project max invocations above core contract set project max invocations"
+        );
+        require(
+            _maxInvocations >= invocations,
+            "Cannot set project max invocations to less than current invocations"
+        );
+
+        // EFFECTS
+        // update storage with results
+        projectConfig[_projectId].maxInvocations = uint24(_maxInvocations);
+        // We need to ensure maxHasBeenInvoked is correctly set after manually setting the
+        // local maxInvocations value.
+        projectConfig[_projectId].maxHasBeenInvoked =
+            invocations == _maxInvocations;
+
+        emit ProjectMaxInvocationsLimitUpdated(_projectId, _maxInvocations);
+    }
+
+    /**
+     * @notice Warning: Disabling purchaseTo is not supported on this minter.
+     * This method exists purely for interface-conformance purposes.
+     */
+    function togglePurchaseToDisabled(
+        uint256 _projectId
+    ) external view onlyArtist(_projectId) {
+        revert("Action not supported");
+    }
+
+    /**
+     * @notice projectId => has project reached its maximum number of
+     * invocations? Note that this returns a local cache of the core contract's
+     * state, and may be out of sync with the core contract. This is
+     * intentional, as it only enables gas optimization of mints after a
+     * project's maximum invocations has been reached. A false negative will
+     * only result in a gas cost increase, since the core contract will still
+     * enforce a maxInvocation check during minting. A false positive is not
+     * possible because the V3 core contract only allows maximum invocations
+     * to be reduced, not increased. Based on this rationale, we intentionally
+     * do not do input validation in this method as to whether or not the input
+     * `_projectId` is an existing project ID.
+     */
+    function projectMaxHasBeenInvoked(
+        uint256 _projectId
+    ) external view returns (bool) {
+        return projectConfig[_projectId].maxHasBeenInvoked;
+    }
+
+    /**
+     * @notice projectId => project's maximum number of invocations.
+     * Optionally synced with core contract value, for gas optimization.
+     * Note that this returns a local cache of the core contract's
+     * state, and may be out of sync with the core contract. This is
+     * intentional, as it only enables gas optimization of mints after a
+     * project's maximum invocations has been reached.
+     * @dev A number greater than the core contract's project max invocations
+     * will only result in a gas cost increase, since the core contract will
+     * still enforce a maxInvocation check during minting. A number less than
+     * the core contract's project max invocations is only possible when the
+     * project's max invocations have not been synced on this minter, since the
+     * V3 core contract only allows maximum invocations to be reduced, not
+     * increased. When this happens, the minter will enable minting, allowing
+     * the core contract to enforce the max invocations check. Based on this
+     * rationale, we intentionally do not do input validation in this method as
+     * to whether or not the input `_projectId` is an existing project ID.
+     */
+    function projectMaxInvocations(
+        uint256 _projectId
+    ) external view returns (uint256) {
+        return uint256(projectConfig[_projectId].maxInvocations);
+    }
+
+    /**
+     * @notice Updates this minter's price per token of project `_projectId`
+     * to be '_pricePerTokenInWei`, in Wei.
+     * This price supersedes any legacy core contract price per token value.
+     * @dev Note that it is intentionally supported here that the configured
+     * price may be explicitly set to `0`.
+     */
+    function updatePricePerTokenInWei(
+        uint256 _projectId,
+        uint256 _pricePerTokenInWei
+    ) external onlyArtist(_projectId) {
+        projectConfig[_projectId].pricePerTokenInWei = _pricePerTokenInWei;
+        projectConfig[_projectId].priceIsConfigured = true;
+        emit PricePerTokenInWeiUpdated(_projectId, _pricePerTokenInWei);
+    }
+
+    /**
+     * @notice Inactive function - requires Merkle proof to purchase.
+     */
+    function purchase(uint256) external payable returns (uint256) {
+        revert("Must provide Merkle proof");
+    }
+
+    /**
+     * @notice Inactive function - requires Merkle proof to purchase.
+     */
+    function purchaseTo(address, uint256) public payable returns (uint256) {
+        revert("Must provide Merkle proof");
+    }
+
+    /**
+     * @notice Purchases a token from project `_projectId`.
+     * @param _projectId Project ID to mint a token on.
+     * @param _proof Merkle proof.
+     * @return tokenId Token ID of minted token
+     */
+    function purchase(
+        uint256 _projectId,
+        bytes32[] calldata _proof
+    ) external payable returns (uint256 tokenId) {
+        tokenId = purchaseTo_kem(msg.sender, _projectId, _proof, address(0));
+        return tokenId;
+    }
+
+    /**
+     * @notice gas-optimized version of purchase(uint256,bytes32[]).
+     */
+    function purchase_gD5(
+        uint256 _projectId,
+        bytes32[] calldata _proof
+    ) external payable returns (uint256 tokenId) {
+        tokenId = purchaseTo_kem(msg.sender, _projectId, _proof, address(0));
+        return tokenId;
+    }
+
+    /**
+     * @notice Purchases a token from project `_projectId` and sets
+     * the token's owner to `_to`.
+     * @param _to Address to be the new token's owner.
+     * @param _projectId Project ID to mint a token on.
+     * @param _proof Merkle proof.
+     * @return tokenId Token ID of minted token
+     */
+    function purchaseTo(
+        address _to,
+        uint256 _projectId,
+        bytes32[] calldata _proof
+    ) external payable returns (uint256 tokenId) {
+        return purchaseTo_kem(_to, _projectId, _proof, address(0));
+    }
+
+    /**
+     * @notice Purchases a token from project `_projectId` and sets
+     *         the token's owner to `_to`, as a delegate, (the `msg.sender`)
+     *         on behalf of an explicitly defined vault.
+     * @param _to Address to be the new token's owner.
+     * @param _projectId Project ID to mint a token on.
+     * @param _proof Merkle proof.
+     * @param _vault Vault being purchased on behalf of.
+     * @return tokenId Token ID of minted token
+     */
+    function purchaseTo(
+        address _to,
+        uint256 _projectId,
+        bytes32[] calldata _proof,
+        address _vault
+    ) external payable returns (uint256 tokenId) {
+        return purchaseTo_kem(_to, _projectId, _proof, _vault);
+    }
+
+    /**
+     * @notice gas-optimized version of
+     * purchaseTo(address,uint256,bytes32[],address).
+     * @param _to Address to be the new token's owner.
+     * @param _projectId Project ID to mint a token on.
+     * @param _proof Merkle proof. Must be a valid proof of either `msg.sender`
+     * if `_vault` is `address(0)`, or `_vault` if `_vault` is not `address(0)`.
+     * @param _vault Vault being purchased on behalf of. Acceptable to be
+     * address(0) if no vault.
+     */
+    function purchaseTo_kem(
+        address _to,
+        uint256 _projectId,
+        bytes32[] calldata _proof,
+        address _vault // acceptable to be `address(0)` if no vault
+    ) public payable nonReentrant returns (uint256 tokenId) {
+        // CHECKS
+        ProjectConfig storage _projectConfig = projectConfig[_projectId];
+
+        // Note that `maxHasBeenInvoked` is only checked here to reduce gas
+        // consumption after a project has been fully minted.
+        // `_projectConfig.maxHasBeenInvoked` is locally cached to reduce
+        // gas consumption, but if not in sync with the core contract's value,
+        // the core contract also enforces its own max invocation check during
+        // minting.
+        require(
+            !_projectConfig.maxHasBeenInvoked,
+            "Maximum number of invocations reached"
+        );
+
+        // load price of token into memory
+        uint256 pricePerTokenInWei = _projectConfig.pricePerTokenInWei;
+
+        require(
+            msg.value >= pricePerTokenInWei,
+            "Must send minimum value to mint!"
+        );
+
+        // require artist to have configured price of token on this minter
+        require(_projectConfig.priceIsConfigured, "Price not configured");
+
+        // no contract filter since Merkle tree controls allowed addresses
+
+        // NOTE: delegate-vault handling **begins here**.
+
+        // handle that the vault may be either the `msg.sender` in the case
+        // that there is not a true vault, or may be `_vault` if one is
+        // provided explicitly (and it is valid).
+        address vault = msg.sender;
+        if (_vault != address(0)) {
+            // If a vault is provided, it must be valid, otherwise throw rather
+            // than optimistically-minting with original `msg.sender`.
+            // Note, we do not check `checkDelegateForAll` as well, as it is known
+            // to be implicitly checked by calling `checkDelegateForContract`.
+            bool isValidDelegee = delegationRegistryContract
+                .checkDelegateForContract(
+                    msg.sender, // delegate
+                    _vault, // vault
+                    genArt721CoreAddress // contract
+                );
+            require(isValidDelegee, "Invalid delegate-vault pairing");
+            vault = _vault;
+        }
+
+        // require valid Merkle proof
+        require(
+            verifyAddress(_projectId, _proof, vault),
+            "Invalid Merkle proof"
+        );
+
+        // limit mints per address by project
+        uint256 _maxProjectInvocationsPerAddress = _projectConfig
+            .useMaxInvocationsPerAddressOverride
+            ? _projectConfig.maxInvocationsPerAddressOverride
+            : DEFAULT_MAX_INVOCATIONS_PER_ADDRESS;
+
+        // note that mint limits index off of the `vault` (when applicable)
+        require(
+            projectUserMintInvocations[_projectId][vault] <
+                _maxProjectInvocationsPerAddress ||
+                _maxProjectInvocationsPerAddress == 0,
+            "Maximum number of invocations per address reached"
+        );
+
+        // EFFECTS
+        // increment user's invocations for this project
+        unchecked {
+            // this will never overflow since user's invocations on a project
+            // are limited by the project's max invocations
+            projectUserMintInvocations[_projectId][vault]++;
+        }
+
+        // mint token
+        tokenId = minterFilter.mint(_to, _projectId, vault);
+
+        // NOTE: delegate-vault handling **ends here**.
+
+        // okay if this underflows because if statement will always eval false.
+        // this is only for gas optimization (core enforces maxInvocations).
+        unchecked {
+            if (tokenId % ONE_MILLION == _projectConfig.maxInvocations - 1) {
+                _projectConfig.maxHasBeenInvoked = true;
+            }
+        }
+
+        // INTERACTIONS
+        splitFundsETH(_projectId, pricePerTokenInWei, genArt721CoreAddress);
+
+        return tokenId;
+    }
+
+    /**
+     * @notice projectId => maximum invocations per allowlisted address. If a
+     * a value of 0 is returned, there is no limit on the number of mints per
+     * allowlisted address.
+     * Default behavior is limit 1 mint per address.
+     * This value can be changed at any time by the artist.
+     * @dev default value stated above must be updated if the value of
+     * CONFIG_USE_MAX_INVOCATIONS_PER_ADDRESS_OVERRIDE is changed.
+     */
+    function projectMaxInvocationsPerAddress(
+        uint256 _projectId
+    ) public view returns (uint256) {
+        ProjectConfig storage _projectConfig = projectConfig[_projectId];
+        if (_projectConfig.useMaxInvocationsPerAddressOverride) {
+            return uint256(_projectConfig.maxInvocationsPerAddressOverride);
+        } else {
+            return DEFAULT_MAX_INVOCATIONS_PER_ADDRESS;
+        }
+    }
+
+    /**
+     * @notice Returns remaining invocations for a given address.
+     * If `projectLimitsMintInvocationsPerAddress` is false, individual
+     * addresses are only limited by the project's maximum invocations, and a
+     * dummy value of zero is returned for `mintInvocationsRemaining`.
+     * If `projectLimitsMintInvocationsPerAddress` is true, the quantity of
+     * remaining mint invocations for address `_address` is returned as
+     * `mintInvocationsRemaining`.
+     * Note that mint invocations per address can be changed at any time by the
+     * artist of a project.
+     * Also note that all mint invocations are limited by a project's maximum
+     * invocations as defined on the core contract. This function may return
+     * a value greater than the project's remaining invocations.
+     */
+    function projectRemainingInvocationsForAddress(
+        uint256 _projectId,
+        address _address
+    )
+        external
+        view
+        returns (
+            bool projectLimitsMintInvocationsPerAddress,
+            uint256 mintInvocationsRemaining
+        )
+    {
+        uint256 maxInvocationsPerAddress = projectMaxInvocationsPerAddress(
+            _projectId
+        );
+        if (maxInvocationsPerAddress == 0) {
+            // project does not limit mint invocations per address, so leave
+            // `projectLimitsMintInvocationsPerAddress` at solidity initial
+            // value of false. Also leave `mintInvocationsRemaining` at
+            // solidity initial value of zero, as indicated in this function's
+            // documentation.
+        } else {
+            projectLimitsMintInvocationsPerAddress = true;
+            uint256 userMintInvocations = projectUserMintInvocations[
+                _projectId
+            ][_address];
+            // if user has not reached max invocations per address, return
+            // remaining invocations
+            if (maxInvocationsPerAddress > userMintInvocations) {
+                unchecked {
+                    // will never underflow due to the check above
+                    mintInvocationsRemaining =
+                        maxInvocationsPerAddress -
+                        userMintInvocations;
+                }
+            }
+            // else user has reached their maximum invocations, so leave
+            // `mintInvocationsRemaining` at solidity initial value of zero
+        }
+    }
+
+    /**
+     * @notice Process proof for an address. Returns Merkle root. Included to
+     * enable users to easily verify a proof's validity.
+     * @param _proof Merkle proof for address.
+     * @param _address Address to process.
+     * @return merkleRoot Merkle root for `_address` and `_proof`
+     */
+    function processProofForAddress(
+        bytes32[] calldata _proof,
+        address _address
+    ) external pure returns (bytes32) {
+        return _proof.processProofCalldata(hashAddress(_address));
+    }
+
+    /**
+     * @notice Gets if price of token is configured, price of minting a
+     * token on project `_projectId`, and currency symbol and address to be
+     * used as payment. Supersedes any core contract price information.
+     * @param _projectId Project ID to get price information for.
+     * @return isConfigured true only if token price has been configured on
+     * this minter
+     * @return tokenPriceInWei current price of token on this minter - invalid
+     * if price has not yet been configured
+     * @return currencySymbol currency symbol for purchases of project on this
+     * minter. This minter always returns "ETH"
+     * @return currencyAddress currency address for purchases of project on
+     * this minter. This minter always returns null address, reserved for ether
+     */
+    function getPriceInfo(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            bool isConfigured,
+            uint256 tokenPriceInWei,
+            string memory currencySymbol,
+            address currencyAddress
+        )
+    {
+        ProjectConfig storage _projectConfig = projectConfig[_projectId];
+        isConfigured = _projectConfig.priceIsConfigured;
+        tokenPriceInWei = _projectConfig.pricePerTokenInWei;
+        currencySymbol = "ETH";
+        currencyAddress = address(0);
+    }
+}