@artblocks/contracts 1.3.1 → 1.4.0

package/contracts/utils/MintMulticallUtil.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+// !!!!! EXPERIMENTAL CONTRACT - NOT FOR PRODUCTION USE !!!!!
+// USE AT YOUR OWN RISK. THIS CONTRACT HAS NOT BEEN AUDITED.
+// Art Blocks Inc. assumes no liability for any loss or damage arising from use
+// of this contract.
+
+pragma solidity 0.8.22;
+
+import {Ownable} from "@openzeppelin-5.0/contracts/access/Ownable.sol";
+
+/// @notice Minimal interface for MinterSetPriceV5 purchaseTo function
+/// @dev Only the purchaseTo function is needed for this utility
+interface IMinterSetPriceV5 {
+    function purchaseTo(
+        address to,
+        uint256 projectId,
+        address coreContract
+    ) external payable returns (uint256 tokenId);
+}
+
+/**
+ * @title MintMulticallUtil
+ * @author Art Blocks Inc.
+ * @notice EXPERIMENTAL - NOT FOR PRODUCTION USE - USE AT YOUR OWN RISK
+ * @dev A personal "multicall" utility contract for MinterSetPriceV5.
+ * Enables a single transaction to call `purchaseTo` on the minter N times,
+ * effectively batching multiple mints into one transaction.
+ *
+ * WARNING: This contract is experimental and has not been audited. It is
+ * provided as-is with no guarantees. Use at your own risk.
+ */
+contract MintMulticallUtil is Ownable {
+    /// @notice Emitted after each successful mint
+    /// @param tokenId The token ID of the newly minted token
+    /// @param to The address that received the minted token
+    event TokenMinted(uint256 indexed tokenId, address indexed to);
+
+    /// @notice Error thrown when array length does not match numMints
+    error ArrayLengthMismatch();
+    /// @notice Error thrown when numMints is zero
+    error ZeroMints();
+    /// @notice Error thrown when a refund transfer fails
+    error RefundFailed();
+
+    /**
+     * @notice Constructor sets the owner of this contract.
+     * @param owner_ The address that will own this contract and be
+     * authorized to call purchaseToMulti.
+     */
+    constructor(address owner_) Ownable(owner_) {}
+
+    /**
+     * @notice Calls purchaseTo on the given minter contract `numMints` times
+     * in a single transaction.
+     * @dev Only callable by the contract owner. Forwards equal shares of
+     * msg.value to each purchaseTo call. Any remaining ETH after all mints
+     * is refunded to the caller.
+     * @param minter The MinterSetPriceV5 contract address to call
+     * purchaseTo on.
+     * @param numMints The number of tokens to mint.
+     * @param toAddresses An array of addresses to mint tokens to, with
+     * length equal to numMints.
+     * @param projectId The project ID on the core contract to mint from.
+     * @param coreContract The Art Blocks core contract address.
+     */
+    function purchaseToMulti(
+        address minter,
+        uint256 numMints,
+        address[] calldata toAddresses,
+        uint256 projectId,
+        address coreContract
+    ) external payable onlyOwner {
+        if (numMints == 0) {
+            revert ZeroMints();
+        }
+        if (toAddresses.length != numMints) {
+            revert ArrayLengthMismatch();
+        }
+
+        uint256 pricePerMint = msg.value / numMints;
+
+        for (uint256 i = 0; i < numMints; ) {
+            uint256 tokenId = IMinterSetPriceV5(minter).purchaseTo{
+                value: pricePerMint
+            }(toAddresses[i], projectId, coreContract);
+
+            emit TokenMinted(tokenId, toAddresses[i]);
+
+            unchecked {
+                ++i;
+            }
+        }
+
+        // Refund any remaining ETH (from rounding)
+        uint256 remaining = address(this).balance;
+        if (remaining > 0) {
+            (bool success, ) = payable(msg.sender).call{value: remaining}("");
+            if (!success) {
+                revert RefundFailed();
+            }
+        }
+    }
+}

package/contracts/web3call/PMPV0.sol

@@ -312,6 +312,8 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
         ProjectConfig storage projectConfig = projectConfigs[coreContract][
             ABHelpers.tokenIdToProjectId(tokenId)
         ];
+        // preallocate memory for auth addresses of each pmpInput
+        address[] memory authAddresses = new address[](pmpInputs.length);
         // assign each pmpInput to the token
         // @dev pmpInputs processed sequentially in order of input
         for (uint256 i = 0; i < pmpInputs.length; i++) {
@@ -322,8 +324,8 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
             ];
             PMPConfigStorage storage pmpConfigStorage = projectConfig
                 .pmpConfigsStorage[pmpKeyHash];
-            // validate pmpInput
-            _validatePMPInputAndAuth({
+            // validate pmpInput + record the authenticated address used to configure the pmpInput
+            authAddresses[i] = _validatePMPInputAndAuth({
                 tokenId: tokenId,
                 coreContract: coreContract,
                 pmpInput: pmpInput,
@@ -360,7 +362,8 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
         emit TokenParamsConfigured({
             coreContract: coreContract,
             tokenId: tokenId,
-            pmpInputs: pmpInputs
+            pmpInputs: pmpInputs,
+            authAddresses: authAddresses
         });
     }
 
@@ -479,20 +482,19 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
      * @param wallet The wallet address to check.
      * @param coreContract The address of the core contract to call.
      * @param tokenId The tokenId of the token to check.
-     * @return isTokenOwnerOrDelegate True if the wallet is the owner or a delegate of the token,
+     * @return isTokenOwnerOrDelegate_ True if the wallet is the owner or a delegate of the token,
      * false otherwise.
      */
     function isTokenOwnerOrDelegate(
         address wallet,
         address coreContract,
         uint256 tokenId
-    ) external view returns (bool) {
-        return
-            _isTokenOwnerOrDelegate({
-                tokenId: tokenId,
-                coreContract: coreContract,
-                sender: wallet
-            });
+    ) external view returns (bool isTokenOwnerOrDelegate_) {
+        (isTokenOwnerOrDelegate_, ) = _isTokenOwnerOrDelegate({
+            tokenId: tokenId,
+            coreContract: coreContract,
+            sender: wallet
+        });
     }
 
     /**
@@ -707,6 +709,7 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
      * @param pmpInput The parameter input to validate.
      * @param pmpConfigStorage The project's configuration storage for this parameter.
      * @param projectConfigNonce The project's current configuration nonce.
+     * @return permissionedAddress the address used to make the update, accounting for delegation.
      */
     function _validatePMPInputAndAuth(
         uint256 tokenId,
@@ -714,7 +717,7 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
         PMPInput memory pmpInput,
         PMPConfigStorage storage pmpConfigStorage,
         uint8 projectConfigNonce
-    ) internal view {
+    ) internal view returns (address permissionedAddress) {
         // check that the param is part of the project's most recently configured PMP params
         // @dev use config nonce to check if param is part of most recently configured PMP params
         require(
@@ -733,88 +736,79 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
         );
 
         // ensure caller has appropriate auth
+        bool isAuthenticated;
         {
-            // @dev block scope to reduce stack depth
+            AuthOption authOption = pmpConfigStorage.authOption;
+            // if artist may configure, check and authenticate if not already authenticated
+            if (
+                authOption == AuthOption.Artist ||
+                authOption == AuthOption.ArtistAndAddress ||
+                authOption == AuthOption.ArtistAndTokenOwner ||
+                authOption == AuthOption.ArtistAndTokenOwnerAndAddress
+            ) {
+                bool isArtist;
+                (isArtist, permissionedAddress) = _isArtist({
+                    tokenId: tokenId,
+                    coreContract: coreContract,
+                    sender: msg.sender
+                });
+                isAuthenticated = isArtist;
+            }
+            // if address may configure, check and authenticate if not already authenticated
+            if (
+                !isAuthenticated &&
+                (authOption == AuthOption.Address ||
+                    authOption == AuthOption.TokenOwnerAndAddress ||
+                    authOption == AuthOption.ArtistAndAddress ||
+                    authOption == AuthOption.ArtistAndTokenOwnerAndAddress)
+            ) {
+                permissionedAddress = pmpConfigStorage.authAddress;
+                isAuthenticated = permissionedAddress == msg.sender;
+            }
+            // if token owner or delegate may configure, check and authenticate
+            // @dev check token ownerlast to enable pre-mint PMP configuration by non-token-owner
+            if (
+                !isAuthenticated &&
+                (authOption == AuthOption.TokenOwner ||
+                    authOption == AuthOption.ArtistAndTokenOwner ||
+                    authOption == AuthOption.TokenOwnerAndAddress ||
+                    authOption == AuthOption.ArtistAndTokenOwnerAndAddress)
+            ) {
+                bool isTokenOwnerOrDelegate_;
+                (
+                    isTokenOwnerOrDelegate_,
+                    permissionedAddress
+                ) = _isTokenOwnerOrDelegate({
+                    tokenId: tokenId,
+                    coreContract: coreContract,
+                    sender: msg.sender
+                });
+                isAuthenticated = isTokenOwnerOrDelegate_;
+            }
+        }
+        // if not authenticated, revert with appropriate auth error
+        if (!isAuthenticated) {
             AuthOption authOption = pmpConfigStorage.authOption;
             if (authOption == AuthOption.Artist) {
-                require(
-                    _isArtist({
-                        tokenId: tokenId,
-                        coreContract: coreContract,
-                        sender: msg.sender
-                    }),
-                    "PMP: artist auth required"
-                );
+                revert("PMP: artist auth required");
             } else if (authOption == AuthOption.TokenOwner) {
-                require(
-                    _isTokenOwnerOrDelegate({
-                        tokenId: tokenId,
-                        coreContract: coreContract,
-                        sender: msg.sender
-                    }),
-                    "PMP: token owner auth required"
-                );
+                revert("PMP: token owner auth required");
             } else if (authOption == AuthOption.ArtistAndTokenOwner) {
-                // @dev check token owner or delegate last to enable pre-mint configuration by non-token-owner
-                require(
-                    _isArtist({
-                        tokenId: tokenId,
-                        coreContract: coreContract,
-                        sender: msg.sender
-                    }) ||
-                        _isTokenOwnerOrDelegate({
-                            tokenId: tokenId,
-                            coreContract: coreContract,
-                            sender: msg.sender
-                        }),
-                    "PMP: artist and token owner auth required"
-                );
+                revert("PMP: artist and token owner auth required");
             } else if (authOption == AuthOption.Address) {
-                require(
-                    msg.sender == pmpConfigStorage.authAddress,
-                    "PMP: address auth required"
-                );
+                revert("PMP: address auth required");
             } else if (authOption == AuthOption.ArtistAndTokenOwnerAndAddress) {
-                // @dev check token owner or delegate last to enable pre-mint configuration by non-token-owner
-                require(
-                    _isArtist({
-                        tokenId: tokenId,
-                        coreContract: coreContract,
-                        sender: msg.sender
-                    }) ||
-                        msg.sender == pmpConfigStorage.authAddress ||
-                        _isTokenOwnerOrDelegate({
-                            tokenId: tokenId,
-                            coreContract: coreContract,
-                            sender: msg.sender
-                        }),
-                    "PMP: artist and token owner and address auth required"
-                );
+                revert("PMP: artist and token owner and address auth required");
             } else if (authOption == AuthOption.ArtistAndAddress) {
-                require(
-                    _isArtist({
-                        tokenId: tokenId,
-                        coreContract: coreContract,
-                        sender: msg.sender
-                    }) || msg.sender == pmpConfigStorage.authAddress,
-                    "PMP: artist and address auth required"
-                );
+                revert("PMP: artist and address auth required");
             } else if (authOption == AuthOption.TokenOwnerAndAddress) {
-                // @dev check token owner or delegate last to enable pre-mint configuration by non-token-owner
-                require(
-                    msg.sender == pmpConfigStorage.authAddress ||
-                        _isTokenOwnerOrDelegate({
-                            tokenId: tokenId,
-                            coreContract: coreContract,
-                            sender: msg.sender
-                        }),
-                    "PMP: token owner and address auth required"
-                );
+                revert("PMP: token owner and address auth required");
             } else {
                 // @dev no coverage, this should never be reached
                 revert("PMP: invalid authOption");
             }
         }
+        // @dev auth check is complete
 
         // ensure properly configured value
         ParamType paramType = pmpConfigStorage.paramType;
@@ -875,12 +869,13 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
             // require artist is caller if configuring artist string
             if (pmpInput.configuringArtistString) {
                 // require artist is caller
+                (bool isArtist, ) = _isArtist({
+                    tokenId: tokenId,
+                    coreContract: coreContract,
+                    sender: msg.sender
+                });
                 require(
-                    _isArtist({
-                        tokenId: tokenId,
-                        coreContract: coreContract,
-                        sender: msg.sender
-                    }),
+                    isArtist,
                     "PMP: artist auth required to configure artist string"
                 );
             }
@@ -1020,17 +1015,18 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
      * @param tokenId The token ID to get the project ID from.
      * @param coreContract The address of the core contract.
      * @param sender The address to check if it's the artist.
-     * @return Returns true if the sender is the artist, false otherwise.
+     * @return isArtist true if the sender is the artist, false otherwise.
+     * @return artistAddress the address of the artist.
      */
     function _isArtist(
         uint256 tokenId,
         address coreContract,
         address sender
-    ) internal view returns (bool) {
+    ) internal view returns (bool isArtist, address artistAddress) {
         uint256 projectId = ABHelpers.tokenIdToProjectId(tokenId);
-        return
-            IGenArt721CoreContractV3_Base(coreContract)
-                .projectIdToArtistAddress(projectId) == sender;
+        artistAddress = IGenArt721CoreContractV3_Base(coreContract)
+            .projectIdToArtistAddress(projectId);
+        isArtist = artistAddress == sender;
     }
 
     /**
@@ -1041,21 +1037,19 @@ contract PMPV0 is IPMPV0, Web3Call, ReentrancyGuard {
      * @param tokenId The token ID to check ownership for.
      * @param coreContract The address of the core contract.
      * @param sender The address to check if it's the token owner.
-     * @return Returns true if the sender is the token owner, false otherwise.
+     * @return isTokenOwnerOrDelegate_ true if the sender is the token owner or delegate of the token owner, false otherwise.
+     * @return tokenOwner the address of the token owner.
      * @dev Always execute within a nonReentrant context.
      */
     function _isTokenOwnerOrDelegate(
         uint256 tokenId,
         address coreContract,
         address sender
-    ) internal view returns (bool) {
+    ) internal view returns (bool isTokenOwnerOrDelegate_, address tokenOwner) {
         // @dev leading interaction - only execute within a nonReentrant context
-        address tokenOwner = IERC721(coreContract).ownerOf(tokenId);
-        if (tokenOwner == sender) {
-            return true;
-        }
-        // @dev delegate.xyz v2 support
-        return
+        tokenOwner = IERC721(coreContract).ownerOf(tokenId);
+        isTokenOwnerOrDelegate_ =
+            (tokenOwner == sender) ||
             delegateRegistry.checkDelegateForERC721({
                 to: sender, // hot wallet
                 from: tokenOwner, // vault