@artblocks/contracts 1.0.4 → 1.2.0

package/contracts/libs/v0.8.x/minter-libs/PolyptychLib.sol

@@ -1,14 +1,16 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-import "../../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
-import "../../../interfaces/v0.8.x/IGenArt721CoreContractExposesHashSeed.sol";
-import "../../../interfaces/v0.8.x/IGenArt721CoreContractV3WithSharedRandomizer.sol";
-import "../../../interfaces/v0.8.x/ISharedRandomizerV0.sol";
+pragma solidity ^0.8.0;
 
-import "@openzeppelin-4.7/contracts/token/ERC20/IERC20.sol";
+import {IGenArt721CoreContractV3_Base} from "../../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
+import {IGenArt721CoreContractExposesHashSeed} from "../../../interfaces/v0.8.x/IGenArt721CoreContractExposesHashSeed.sol";
+import {IGenArt721CoreContractV3WithSharedRandomizer} from "../../../interfaces/v0.8.x/IGenArt721CoreContractV3WithSharedRandomizer.sol";
+import {ISharedRandomizerV0} from "../../../interfaces/v0.8.x/ISharedRandomizerV0.sol";
 
-pragma solidity ^0.8.0;
+import {GenericMinterEventsLib} from "./GenericMinterEventsLib.sol";
+
+import {IERC20} from "@openzeppelin-4.7/contracts/token/ERC20/IERC20.sol";
 
 /**
  * @title Art Blocks Polyptych Minter Library
@@ -20,23 +22,48 @@ pragma solidity ^0.8.0;
 library PolyptychLib {
     bytes32 constant POLYPTYCH_PANEL_ID = "polyptychPanelId";
 
+    // position of Polyptych Lib storage, using a diamond storage pattern
+    // for this library
+    bytes32 constant POLYPTYCH_LIB_STORAGE_POSITION =
+        keccak256("polyptychlib.storage");
+
     struct PolyptychProjectConfig {
         // @dev uint24 provides sufficient qty of panels, and could be packed
         // in the future if other values are added to this struct.
         uint24 polyptychPanelId;
         // Stores whether a panel with an ID has been minted for a given token hash seed
-        // panelId => hashSeed => panelIsMinted
-        mapping(uint256 => mapping(bytes12 => bool)) polyptychPanelHashSeedIsMinted;
+        mapping(uint256 panelId => mapping(bytes12 hashSeed => bool panelIsMinted)) polyptychPanelHashSeedIsMinted;
+    }
+
+    // Diamond storage pattern is used in this library
+    struct PolyptychLibStorage {
+        mapping(address coreContract => mapping(uint256 projectId => PolyptychProjectConfig)) polyptychProjectConfigs;
     }
 
     /**
      * @notice Increments the minter to the next polyptych panel of a given project
-     * @param _polyptychProjectConfig Project ID to increment to its next polyptych panel
+     * @param projectId Project ID to increment panel ID for
+     * @param coreContract Core contract address that _projectId is on
      */
     function incrementPolyptychProjectPanelId(
-        PolyptychProjectConfig storage _polyptychProjectConfig
+        uint256 projectId,
+        address coreContract
     ) internal {
-        ++_polyptychProjectConfig.polyptychPanelId;
+        PolyptychProjectConfig
+            storage polyptychProjectConfig = getPolyptychProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
+        // increment panel ID
+        ++polyptychProjectConfig.polyptychPanelId;
+
+        // index the update
+        emit GenericMinterEventsLib.ConfigValueSet({
+            projectId: projectId,
+            coreContract: coreContract,
+            key: PolyptychLib.POLYPTYCH_PANEL_ID,
+            value: polyptychProjectConfig.polyptychPanelId
+        });
     }
 
     /**
@@ -44,26 +71,33 @@ library PolyptychLib {
      * minter.
      * Verifies that the token hash seed is non-zero, and also enforces that
      * the hash seed can only be used up to one time per panel.
-     * @param _polyptychProjectConfig polyptych project config
-     * @param _tokenHashSeed token hash seed
+     * @param projectId Project ID to validate
+     * @param coreContract Core contract address to validate
+     * @param tokenHashSeed token hash seed
      */
     function validatePolyptychEffects(
-        PolyptychProjectConfig storage _polyptychProjectConfig,
-        bytes12 _tokenHashSeed
+        uint256 projectId,
+        address coreContract,
+        bytes12 tokenHashSeed
     ) internal {
+        PolyptychProjectConfig
+            storage polyptychProjectConfig = getPolyptychProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
         // ensure non-zero hash seed
-        require(_tokenHashSeed != bytes12(0), "Only non-zero hash seeds");
+        require(tokenHashSeed != bytes12(0), "Only non-zero hash seeds");
         // verify that the hash seed has not been used on the current panel
-        uint256 _panelId = _polyptychProjectConfig.polyptychPanelId;
+        uint256 panelId = polyptychProjectConfig.polyptychPanelId;
         require(
-            !_polyptychProjectConfig.polyptychPanelHashSeedIsMinted[_panelId][
-                _tokenHashSeed
+            !polyptychProjectConfig.polyptychPanelHashSeedIsMinted[panelId][
+                tokenHashSeed
             ],
             "Panel already minted"
         );
         // mark hash seed as used for the current panel
-        _polyptychProjectConfig.polyptychPanelHashSeedIsMinted[_panelId][
-            _tokenHashSeed
+        polyptychProjectConfig.polyptychPanelHashSeedIsMinted[panelId][
+            tokenHashSeed
         ] = true;
     }
 
@@ -72,40 +106,43 @@ library PolyptychLib {
      * token ID on a core contract.
      * @dev This function assumes the core contract is configured to use a
      * shared randomizer that supports polyptych minting.
-     * @param _coreContract Core contract address
-     * @param _tokenId Token ID to set hash seed for
-     * @param _hashSeed Hash seed to set
+     * @param coreContract Core contract address
+     * @param tokenId Token ID to set hash seed for
+     * @param hashSeed Hash seed to set
      */
     function setPolyptychHashSeed(
-        address _coreContract,
-        uint256 _tokenId,
-        bytes12 _hashSeed
+        address coreContract,
+        uint256 tokenId,
+        bytes12 hashSeed
     ) internal {
-        IGenArt721CoreContractV3WithSharedRandomizer(_coreContract)
+        IGenArt721CoreContractV3WithSharedRandomizer(coreContract)
             .randomizerContract()
             .preSetHashSeed({
-                _coreContract: _coreContract,
-                _tokenId: _tokenId,
-                _hashSeed: _hashSeed
+                coreContract: coreContract,
+                tokenId: tokenId,
+                hashSeed: hashSeed
             });
     }
 
     /**
-     * Validates that token hash seed is assigned to the token ID `_tokenId` on
-     * the core contract `_coreContract`.
+     * Validates that token hash seed is assigned to the token ID `tokenId` on
+     * the core contract `coreContract`.
      * Reverts if hash seed is not assigned to the token ID.
-     * @param _coreContract Core contract address
-     * @param _tokenId Token ID to validate
-     * @param _targetHashSeed target hash seed of `_tokenId` on `_coreContract`
+     * @param coreContract Core contract address
+     * @param tokenId Token ID to validate
+     * @param targetHashSeed target hash seed of `tokenId` on `coreContract`
      */
     function validateAssignedHashSeed(
-        address _coreContract,
-        uint256 _tokenId,
-        bytes12 _targetHashSeed
+        address coreContract,
+        uint256 tokenId,
+        bytes12 targetHashSeed
     ) internal view {
-        bytes12 _assignedHashSeed = getTokenHashSeed(_coreContract, _tokenId);
+        bytes12 assignedHashSeed = getTokenHashSeed({
+            coreContract: coreContract,
+            tokenId: tokenId
+        });
         require(
-            _assignedHashSeed == _targetHashSeed,
+            assignedHashSeed == targetHashSeed,
             "Unexpected token hash seed"
         );
     }
@@ -116,45 +153,88 @@ library PolyptychLib {
      * `IGenArt721CoreContractExposesHashSeed`, which early versions of V3
      * core contracts do not. If a contract does not conform to this interface,
      * this function will revert.
-     * @param _coreContract Core contract address
-     * @param _tokenId Token ID to query hash seed for
+     * @param coreContract Core contract address
+     * @param tokenId Token ID to query hash seed for
      */
     function getTokenHashSeed(
-        address _coreContract,
-        uint256 _tokenId
+        address coreContract,
+        uint256 tokenId
     ) internal view returns (bytes12) {
         return
-            IGenArt721CoreContractExposesHashSeed(_coreContract)
-                .tokenIdToHashSeed(_tokenId);
+            IGenArt721CoreContractExposesHashSeed(coreContract)
+                .tokenIdToHashSeed(tokenId);
     }
 
     /**
      * Gets the current polyptych panel ID from polyptych project config.
      * Polyptych panel ID is an incremented value that is used to track the
      * current panel of a polyptych project.
-     * @param _polyptychProjectConfig Polyptych project config struct to query
+     * @param projectId Project ID to query
+     * @param coreContract Core contract address to query
      */
     function getPolyptychPanelId(
-        PolyptychProjectConfig storage _polyptychProjectConfig
+        uint256 projectId,
+        address coreContract
     ) internal view returns (uint256) {
-        return _polyptychProjectConfig.polyptychPanelId;
+        PolyptychProjectConfig
+            storage polyptychProjectConfig = getPolyptychProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
+        return polyptychProjectConfig.polyptychPanelId;
     }
 
     /**
      * Gets if a polyptych panel has already been minted for a given panel ID
      * and hash seed.
-     * @param _polyptychProjectConfig Polyptych project config struct to query
-     * @param _panelId Polyptych panel ID to query
-     * @param _hashSeed Hash seed of panel to query
+     * @param projectId Project ID to query
+     * @param coreContract Core contract address to query
+     * @param panelId Polyptych panel ID to query
+     * @param hashSeed Hash seed of panel to query
      */
     function getPolyptychPanelHashSeedIsMinted(
-        PolyptychProjectConfig storage _polyptychProjectConfig,
-        uint256 _panelId,
-        bytes12 _hashSeed
+        uint256 projectId,
+        address coreContract,
+        uint256 panelId,
+        bytes12 hashSeed
     ) internal view returns (bool) {
+        PolyptychProjectConfig
+            storage polyptychProjectConfig = getPolyptychProjectConfig({
+                projectId: projectId,
+                coreContract: coreContract
+            });
         return
-            _polyptychProjectConfig.polyptychPanelHashSeedIsMinted[_panelId][
-                _hashSeed
+            polyptychProjectConfig.polyptychPanelHashSeedIsMinted[panelId][
+                hashSeed
             ];
     }
+
+    /**
+     * Loads the PolyptychProjectConfig for a given project and core
+     * contract.
+     * @param projectId Project Id to get config for
+     * @param coreContract Core contract address to get config for
+     */
+    function getPolyptychProjectConfig(
+        uint256 projectId,
+        address coreContract
+    ) internal view returns (PolyptychProjectConfig storage) {
+        return s().polyptychProjectConfigs[coreContract][projectId];
+    }
+
+    /**
+     * @notice Return the storage struct for reading and writing. This library
+     * uses a diamond storage pattern when managing storage.
+     * @return storageStruct The PolyptychLibStorage struct.
+     */
+    function s()
+        internal
+        pure
+        returns (PolyptychLibStorage storage storageStruct)
+    {
+        bytes32 position = POLYPTYCH_LIB_STORAGE_POSITION;
+        assembly ("memory-safe") {
+            storageStruct.slot := position
+        }
+    }
 }