@artblocks/contracts 1.2.0 → 1.3.0

package/contracts/DependencyRegistryV0.sol

@@ -6,6 +6,9 @@ pragma solidity 0.8.19;
 import "./interfaces/v0.8.x/IAdminACLV0.sol";
 import "./interfaces/v0.8.x/IDependencyRegistryCompatibleV0.sol";
 import "./interfaces/v0.8.x/IDependencyRegistryV0.sol";
+import "./interfaces/v0.8.x/ICoreRegistryV1.sol";
+import "./interfaces/v0.8.x/IBytecodeStorageReaderV2.sol";
+import "./interfaces/v0.8.x/IUniversalBytecodeStorageReader.sol";
 
 import "@openzeppelin-4.7/contracts/utils/Strings.sol";
 import "@openzeppelin-4.7/contracts/utils/structs/EnumerableSet.sol";
@@ -14,7 +17,7 @@ import "@openzeppelin-4.8/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin-4.5/contracts/utils/math/SafeCast.sol";
 
 import "./libs/v0.8.x/DependencyRegistryStorageLib.sol";
-import "./libs/v0.8.x/BytecodeStorageV1.sol";
+import "./libs/v0.8.x/BytecodeStorageV2.sol";
 import "./libs/v0.8.x/Bytes32Strings.sol";
 
 /**
@@ -36,6 +39,7 @@ contract DependencyRegistryV0 is
 {
     using BytecodeStorageWriter for string;
     using Bytes32Strings for bytes32;
+    using Bytes32Strings for string;
     using Strings for uint256;
     using EnumerableSet for EnumerableSet.Bytes32Set;
     using EnumerableSet for EnumerableSet.AddressSet;
@@ -65,10 +69,9 @@ contract DependencyRegistryV0 is
     function _onlySupportedCoreContract(
         address coreContractAddress
     ) internal view {
+        // defer to public function logic
         require(
-            DependencyRegistryStorageLib.s().supportedCoreContracts.contains(
-                coreContractAddress
-            ),
+            isSupportedCoreContract(coreContractAddress),
             "Core contract not supported"
         );
     }
@@ -95,6 +98,10 @@ contract DependencyRegistryV0 is
         );
     }
 
+    function _onlyBytes32String(string memory input) internal pure {
+        require(bytes(input).length <= 32, "String too long");
+    }
+
     /**
      * @notice Initializes contract.
      * @param adminACLContract_ Address of admin access control contract, to be
@@ -107,6 +114,30 @@ contract DependencyRegistryV0 is
         _transferOwnership(adminACLContract_);
     }
 
+    function updateUniversalBytecodeStorageReader(address newReader) external {
+        _onlyAdminACL(this.updateUniversalBytecodeStorageReader.selector);
+        _onlyNonZeroAddress(newReader);
+        DependencyRegistryStorageLib
+            .s()
+            .universalReader = IUniversalBytecodeStorageReader(newReader);
+        emit UniversalBytecodeStorageReaderUpdated(newReader);
+    }
+
+    /**
+     * @notice Updates the core registry address.
+     * @param _coreRegistryAddress Address of core registry contract.
+     */
+    function updateCoreRegistryAddress(address _coreRegistryAddress) external {
+        _onlyAdminACL(this.updateCoreRegistryAddress.selector);
+        _onlyNonZeroAddress(_coreRegistryAddress);
+        DependencyRegistryStorageLib.s().coreRegistryContract = ICoreRegistryV1(
+            _coreRegistryAddress
+        );
+        emit CoreRegistryAddressUpdated({
+            coreRegistryAddress: _coreRegistryAddress
+        });
+    }
+
     /**
      * @notice Adds a new license type that can be used by dependencies.
      * @param licenseType License type to be added.
@@ -612,37 +643,85 @@ contract DependencyRegistryV0 is
     }
 
     /**
-     * @notice Adds a new core contract to the list of supported core contracts.
-     * @param contractAddress Address of the core contract to be added.
+     * @notice These functions were removed in an upgrade, registering and unregistering
+     * contracts are handled by the core registry.
      */
-    function addSupportedCoreContract(address contractAddress) external {
-        _onlyAdminACL(this.addSupportedCoreContract.selector);
+    // /**
+    //  * @notice Adds a new core contract to the list of supported core contracts.
+    //  * @param contractAddress Address of the core contract to be added.
+    //  */
+    // function addSupportedCoreContract(address contractAddress) external {
+    //     _onlyAdminACL(this.addSupportedCoreContract.selector);
+    //     _onlyNonZeroAddress(contractAddress);
+
+    //     require(
+    //         // @dev the add function returns false if set already contains value
+    //         DependencyRegistryStorageLib.s().supportedCoreContracts.add(
+    //             contractAddress
+    //         ),
+    //         "Contract already supported"
+    //     );
+    //     emit SupportedCoreContractAdded(contractAddress);
+    // }
+
+    // /**
+    //  * @notice Removes a core contract from the list of supported core contracts.
+    //  * @param contractAddress Address of the core contract to be removed.
+    //  */
+    // function removeSupportedCoreContract(address contractAddress) external {
+    //     _onlyAdminACL(this.removeSupportedCoreContract.selector);
+    //     require(
+    //         // @dev the remove function returns false if set does not contain value
+    //         DependencyRegistryStorageLib.s().supportedCoreContracts.remove(
+    //             contractAddress
+    //         ),
+    //         "Core contract already removed or not in set"
+    //     );
+    //     emit SupportedCoreContractRemoved(contractAddress);
+    // }
+
+    /**
+     * @notice Adds a new core contract to be supported by the dependency registry.
+     * This is in addition to the set of contracts specified as supported by the core registry.
+     * @dev use case is a contract not allowed to mint on minter filter, but still needs to be
+     * supported by dependency registry.
+     * @param contractAddress Address of the core contract.
+     */
+    function addSupportedCoreContractOverride(
+        address contractAddress
+    ) external {
+        _onlyAdminACL(this.addSupportedCoreContractOverride.selector);
         _onlyNonZeroAddress(contractAddress);
 
         require(
             // @dev the add function returns false if set already contains value
-            DependencyRegistryStorageLib.s().supportedCoreContracts.add(
+            DependencyRegistryStorageLib.s().supportedCoreContractsOverride.add(
                 contractAddress
             ),
             "Contract already supported"
         );
-        emit SupportedCoreContractAdded(contractAddress);
+        emit SupportedCoreContractOverrideAdded(contractAddress);
     }
 
     /**
-     * @notice Removes a core contract from the list of supported core contracts.
-     * @param contractAddress Address of the core contract to be removed.
+     * @notice Removes a core contract previously listed as override supported by the dependency registry.
+     * This removes from the set of core contracts that are suppported by the dependency in addition to
+     * the set of contracts specified as supported by the core registry.
+     * @param contractAddress Address of the core contract.
      */
-    function removeSupportedCoreContract(address contractAddress) external {
-        _onlyAdminACL(this.removeSupportedCoreContract.selector);
+    function removeSupportedCoreContractOverride(
+        address contractAddress
+    ) external {
+        _onlyAdminACL(this.removeSupportedCoreContractOverride.selector);
         require(
             // @dev the remove function returns false if set does not contain value
-            DependencyRegistryStorageLib.s().supportedCoreContracts.remove(
-                contractAddress
-            ),
+            DependencyRegistryStorageLib
+                .s()
+                .supportedCoreContractsOverride
+                .remove(contractAddress),
             "Core contract already removed or not in set"
         );
-        emit SupportedCoreContractRemoved(contractAddress);
+        emit SupportedCoreContractOverrideRemoved(contractAddress);
     }
 
     /**
@@ -901,18 +980,7 @@ contract DependencyRegistryV0 is
         });
 
         address licenseAddress = licenseEntry.licenseBytecodeAddresses[index];
-        bytes32 storageVersion = BytecodeStorageReader
-            .getLibraryVersionForBytecode(licenseAddress);
-        if (storageVersion == BytecodeStorageReader.UNKNOWN_VERSION_STRING) {
-            return
-                string(
-                    BytecodeStorageReader.readBytesFromSSTORE2Bytecode(
-                        licenseAddress
-                    )
-                );
-        } else {
-            return BytecodeStorageReader.readFromBytecode(licenseAddress);
-        }
+        return _readFromBytecodeWithSSTORE2Fallback(licenseAddress);
     }
 
     /**
@@ -930,7 +998,8 @@ contract DependencyRegistryV0 is
     }
 
     /**
-     * @notice Returns details for a given dependency type `dependencyNameAndVersion`.
+     * @notice Returns details for a given dependency type `dependencyNameAndVersion` input as string.
+     * Reverts if input string does not fit within 32 bytes.
      * @param dependencyNameAndVersion Name and version of dependency (i.e. "name@version") used to identify dependency.
      * @return nameAndVersion String representation of `dependencyNameAndVersion`.
      *                        (e.g. "p5js(atSymbol)1.0.0")
@@ -943,8 +1012,8 @@ contract DependencyRegistryV0 is
      * @return availableOnChain Whether dependency is available on chain
      * @return scriptCount Count of on-chain scripts for dependency
      */
-    function getDependencyDetails(
-        bytes32 dependencyNameAndVersion
+    function getDependencyDetailsFromString(
+        string memory dependencyNameAndVersion
     )
         external
         view
@@ -960,64 +1029,86 @@ contract DependencyRegistryV0 is
             uint24 scriptCount
         )
     {
-        DependencyRegistryStorageLib.Dependency
-            storage dependency = DependencyRegistryStorageLib
-                .s()
-                .dependencyRecords[dependencyNameAndVersion];
-
-        return (
-            dependencyNameAndVersion.toString(),
-            dependency.licenseType.toString(),
-            dependency.preferredCDN,
-            dependency.additionalCDNCount,
-            dependency.preferredRepository,
-            dependency.additionalRepositoryCount,
-            dependency.website,
-            dependency.scriptCount > 0,
-            dependency.scriptCount
-        );
+        _onlyBytes32String(dependencyNameAndVersion);
+        return getDependencyDetails(dependencyNameAndVersion.stringToBytes32());
     }
 
     /**
      * @notice Returns the count of supported core contracts
+     * @dev This concatenates the core contracts from the core registry with the
+     * core contracts that are overridden as supported by the dependency registry.
+     * Some duplicate entries may exist between the two sets, although this is not
+     * intended to be the case.
      * @return Number of supported core contracts.
      */
     function getSupportedCoreContractCount() external view returns (uint256) {
-        return DependencyRegistryStorageLib.s().supportedCoreContracts.length();
+        uint256 coreRegistryCount = ICoreRegistryV1(
+            DependencyRegistryStorageLib.s().coreRegistryContract
+        ).getNumRegisteredContracts();
+        uint256 overrideCount = DependencyRegistryStorageLib
+            .s()
+            .supportedCoreContractsOverride
+            .length();
+        return coreRegistryCount + overrideCount;
     }
 
     /**
      * @notice Returns the address of the supported core contract at index `index`.
+     * @dev This concatenates the core contracts from the core registry with the
+     * core contracts that are overridden as supported by the dependency registry, and
+     * consistent with the length returned by `getSupportedCoreContractCount`.
      * @param index Index of the core contract to be returned, relative to the overall
-     *               list of supported core contracts.
+     * list of supported core contracts.
      * @return address of the core contract.
      */
     function getSupportedCoreContract(
         uint256 index
     ) external view returns (address) {
-        DependencyRegistryStorageLib.Storage
-            storage ds = DependencyRegistryStorageLib.s();
-
-        _onlyInRangeIndex({
-            index: index,
-            length: ds.supportedCoreContracts.length()
-        });
+        uint256 coreRegistryCount = ICoreRegistryV1(
+            DependencyRegistryStorageLib.s().coreRegistryContract
+        ).getNumRegisteredContracts();
+        if (index < coreRegistryCount) {
+            return
+                ICoreRegistryV1(
+                    DependencyRegistryStorageLib.s().coreRegistryContract
+                ).getRegisteredContractAt(index);
+        }
+        uint256 overrideCount = DependencyRegistryStorageLib
+            .s()
+            .supportedCoreContractsOverride
+            .length();
+        require(
+            index < coreRegistryCount + overrideCount,
+            "Index out of range"
+        );
 
-        return ds.supportedCoreContracts.at(index);
+        unchecked {
+            return
+                DependencyRegistryStorageLib
+                    .s()
+                    .supportedCoreContractsOverride
+                    .at(index - coreRegistryCount);
+        }
     }
 
     /**
      * @notice Returns whether the given contract address is a supported core contract.
+     * @dev This checks if the given contract address is registered in the core registry
+     * or if it is overridden as supported by the dependency registry.
      * @param coreContractAddress Address of the core contract to be queried.
      * @return True if the given contract address is a supported core contract.
      */
     function isSupportedCoreContract(
         address coreContractAddress
-    ) external view returns (bool) {
+    ) public view returns (bool) {
         return
-            DependencyRegistryStorageLib.s().supportedCoreContracts.contains(
-                coreContractAddress
-            );
+            ICoreRegistryV1(
+                DependencyRegistryStorageLib.s().coreRegistryContract
+            ).isRegisteredContract(coreContractAddress) ||
+            DependencyRegistryStorageLib
+                .s()
+                .supportedCoreContractsOverride
+                .contains(coreContractAddress);
     }
 
     /**
@@ -1031,21 +1122,36 @@ contract DependencyRegistryV0 is
         view
         returns (address[] memory)
     {
-        DependencyRegistryStorageLib.Storage
-            storage ds = DependencyRegistryStorageLib.s();
+        // get all registered contracts on the core registry
+        address[] memory coreRegistryRegisteredContracts = ICoreRegistryV1(
+            DependencyRegistryStorageLib.s().coreRegistryContract
+        ).getAllRegisteredContracts();
+        // @dev memoize for efficiency
+        uint256 coreRegistryRegisteredContractsLength = coreRegistryRegisteredContracts
+                .length;
+        // get all overridden contracts in the supportedCoreContractsOverride set
+        address[]
+            memory supportedCoreContractsOverride = DependencyRegistryStorageLib
+                .s()
+                .supportedCoreContractsOverride
+                .values();
 
-        uint256 supportedCoreContractCount = ds.supportedCoreContracts.length();
+        // concat the two address arrays and return the result
         address[] memory supportedCoreContracts = new address[](
-            supportedCoreContractCount
+            coreRegistryRegisteredContracts.length +
+                supportedCoreContractsOverride.length
         );
-
-        for (uint256 i; i < supportedCoreContractCount; ) {
-            supportedCoreContracts[i] = ds.supportedCoreContracts.at(i);
-            unchecked {
-                ++i;
+        // @dev memoize for efficiency
+        uint256 supportedCoreContractsLength = supportedCoreContracts.length;
+        for (uint i = 0; i < supportedCoreContractsLength; i++) {
+            if (i < coreRegistryRegisteredContractsLength) {
+                supportedCoreContracts[i] = coreRegistryRegisteredContracts[i];
+            } else {
+                supportedCoreContracts[i] = supportedCoreContractsOverride[
+                    i - coreRegistryRegisteredContractsLength
+                ];
             }
         }
-
         return supportedCoreContracts;
     }
 
@@ -1144,9 +1250,10 @@ contract DependencyRegistryV0 is
                 .dependencyRecords[dependencyNameAndVersion];
         _onlyInRangeIndex({index: index, length: dependency.scriptCount});
         return
-            BytecodeStorageReader.getLibraryVersionForBytecode(
-                dependency.scriptBytecodeAddresses[index]
-            );
+            _getActiveBytecodeStorageReaderContract()
+                .getLibraryVersionForBytecode(
+                    dependency.scriptBytecodeAddresses[index]
+                );
     }
 
     /**
@@ -1173,19 +1280,8 @@ contract DependencyRegistryV0 is
         _onlyInRangeIndex({index: index, length: dependency.scriptCount});
 
         address scriptAddress = dependency.scriptBytecodeAddresses[index];
-        bytes32 storageVersion = BytecodeStorageReader
-            .getLibraryVersionForBytecode(scriptAddress);
 
-        if (storageVersion == BytecodeStorageReader.UNKNOWN_VERSION_STRING) {
-            return
-                string(
-                    BytecodeStorageReader.readBytesFromSSTORE2Bytecode(
-                        scriptAddress
-                    )
-                );
-        } else {
-            return BytecodeStorageReader.readFromBytecode(scriptAddress);
-        }
+        return _readFromBytecodeWithSSTORE2Fallback(scriptAddress);
     }
 
     /**
@@ -1223,6 +1319,28 @@ contract DependencyRegistryV0 is
         }
     }
 
+    /**
+     * @notice returns the address of the core registry currently being used by the dependency registry.
+     * @return address Address of the core registry contract.
+     */
+    function currentCoreRegistry() external view returns (address) {
+        return address(DependencyRegistryStorageLib.s().coreRegistryContract);
+    }
+
+    /**
+     * @notice utility function to convert from string to bytes32.
+     * Useful when a human is calling functions that take bytes32 as input.
+     * Reverts if input string does not fit within 32 bytes.
+     * @param input String to convert to bytes32.
+     * @return bytes32 representation of input.
+     */
+    function stringToBytes32(
+        string memory input
+    ) external pure returns (bytes32) {
+        _onlyBytes32String(input);
+        return input.stringToBytes32();
+    }
+
     /**
      * @notice Convenience function that returns whether `_sender` is allowed
      * to call function with selector `_selector` on contract `_contract`, as
@@ -1256,6 +1374,55 @@ contract DependencyRegistryV0 is
             );
     }
 
+    /**
+     * @notice Returns details for a given dependency type `dependencyNameAndVersion`.
+     * @param dependencyNameAndVersion Name and version of dependency (i.e. "name@version") used to identify dependency.
+     * @return nameAndVersion String representation of `dependencyNameAndVersion`.
+     *                        (e.g. "p5js(atSymbol)1.0.0")
+     * @return licenseType License type for dependency
+     * @return preferredCDN Preferred CDN URL for dependency
+     * @return additionalCDNCount Count of additional CDN URLs for dependency
+     * @return preferredRepository Preferred repository URL for dependency
+     * @return additionalRepositoryCount Count of additional repository URLs for dependency
+     * @return dependencyWebsite Project website URL for dependency
+     * @return availableOnChain Whether dependency is available on chain
+     * @return scriptCount Count of on-chain scripts for dependency
+     */
+    function getDependencyDetails(
+        bytes32 dependencyNameAndVersion
+    )
+        public
+        view
+        returns (
+            string memory nameAndVersion,
+            string memory licenseType,
+            string memory preferredCDN,
+            uint24 additionalCDNCount,
+            string memory preferredRepository,
+            uint24 additionalRepositoryCount,
+            string memory dependencyWebsite,
+            bool availableOnChain,
+            uint24 scriptCount
+        )
+    {
+        DependencyRegistryStorageLib.Dependency
+            storage dependency = DependencyRegistryStorageLib
+                .s()
+                .dependencyRecords[dependencyNameAndVersion];
+
+        return (
+            dependencyNameAndVersion.toString(),
+            dependency.licenseType.toString(),
+            dependency.preferredCDN,
+            dependency.additionalCDNCount,
+            dependency.preferredRepository,
+            dependency.additionalRepositoryCount,
+            dependency.website,
+            dependency.scriptCount > 0,
+            dependency.scriptCount
+        );
+    }
+
     /**
      * @notice Returns contract owner. Set to deployer's address by default on
      * contract deployment.
@@ -1294,4 +1461,45 @@ contract DependencyRegistryV0 is
             newOwner
         );
     }
+
+    /**
+     * @notice Reads data from bytecode with SSTORE2 fallback.
+     * @param dataAddress Address of the data to read.
+     * @return data String representation of the data.
+     */
+    function _readFromBytecodeWithSSTORE2Fallback(
+        address dataAddress
+    ) internal view returns (string memory) {
+        IBytecodeStorageReaderV2 activeReader = _getActiveBytecodeStorageReaderContract();
+        bytes32 storageVersion = activeReader.getLibraryVersionForBytecode(
+            dataAddress
+        );
+        if (storageVersion == BytecodeStorageReader.UNKNOWN_VERSION_STRING) {
+            return
+                string(activeReader.readBytesFromSSTORE2Bytecode(dataAddress));
+        } else {
+            return activeReader.readFromBytecode(dataAddress);
+        }
+    }
+
+    /**
+     * @notice Returns the active bytecode storage reader contract, being used by the universal reader contract.
+     * @dev assumes the versioned reader is IBytecodeStorageReaderV2 or higher.
+     * @return IBytecodeStorageReaderV2 The active bytecode storage reader contract.
+     */
+    function _getActiveBytecodeStorageReaderContract()
+        internal
+        view
+        returns (IBytecodeStorageReaderV2)
+    {
+        return
+            IBytecodeStorageReaderV2(
+                address(
+                    DependencyRegistryStorageLib
+                        .s()
+                        .universalReader
+                        .activeBytecodeStorageReaderContract()
+                )
+            );
+    }
 }

package/contracts/GenArt721CoreV3_Curated.sol

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+// Created By: Art Blocks Inc.
+
+import {GenArt721CoreV3_Engine} from "./engine/V3/GenArt721CoreV3_Engine.sol";
+import {EngineConfiguration} from "./interfaces/v0.8.x/IGenArt721CoreContractV3_Engine.sol";
+
+import "./libs/v0.8.x/Bytes32Strings.sol";
+
+/**
+ * @title Art Blocks Curated ERC-721 core contract, V3.2
+ * @author Art Blocks Inc.
+ * @notice This contract derives from the Art Blocks Engine contract and adds
+ * some functionality to support curation of projects by Art Blocks.
+ * It also performs initialization of the contract in the constructor, because
+ * the contract is not intended to use a clone proxy pattern, and is intended
+ * to be deployed without any required follow-on calls to initialize.
+ * ----------------------------------------------------------------------------
+ * See the Art Blocks Engine contract for additional applicable documentation.
+ */
+contract GenArt721CoreV3_Curated is GenArt721CoreV3_Engine {
+    using Bytes32Strings for bytes32;
+
+    /// override patch version of this core contract
+    // @dev this is a constant value that is used to override the inherited core version CORE_VERSION
+    bytes32 private constant _CORE_VERSION_OVERRIDE = "v3.2.6";
+
+    // @dev overridden core version is returned instead of the inherited core version
+    function coreVersion() external pure override returns (string memory) {
+        return _CORE_VERSION_OVERRIDE.toString();
+    }
+
+    /// metadata pointer to the previous associated Flagship Artblocks core contracts
+    // @dev not defined as constant because constant address arrays are not yet implemented in Solidity
+    address[] public PREVIOUS_ART_BLOCKS_CONTRACTS = [
+        0x059EDD72Cd353dF5106D2B9cC5ab83a52287aC3a,
+        0xa7d8d9ef8D8Ce8992Df33D8b8CF4Aebabd5bD270,
+        0x99a9B7c1116f9ceEB1652de04d5969CcE509B069
+    ];
+
+    /// Curation registry for Flagship projects, managed by Art Blocks
+    address public artblocksCurationRegistryAddress;
+
+    bool public constant IS_FLAGSHIP = true;
+
+    /**
+     * @notice Construct a new curated Art Blocks ERC-721 core contract.
+     * Performs all contract initialization in the constructor.
+     * @param engineConfiguration Configuration for the engine contract.
+     * note: parameter `engineConfiguration.newSuperAdminAddress` is not used or operated on in this contract.
+     * @param adminACLContract_ Address of the admin ACL contract.
+     * @param defaultBaseURIHost Default base URI host for token URIs, e.g. "https://token.artblocks.io/" for mainnet
+     * @param bytecodeStorageReaderContract_ Address of the bytecode storage reader contract to be used by this
+     * contract.
+     */
+    constructor(
+        EngineConfiguration memory engineConfiguration,
+        address adminACLContract_,
+        string memory defaultBaseURIHost,
+        address bytecodeStorageReaderContract_
+    ) GenArt721CoreV3_Engine() {
+        // input validation generally performed by the engine factory
+        _onlyNonZeroAddress(engineConfiguration.renderProviderAddress);
+        _onlyNonZeroAddress(engineConfiguration.randomizerContract);
+        _onlyNonZeroAddress(adminACLContract_);
+        _onlyNonZeroAddress(bytecodeStorageReaderContract_);
+        require(
+            bytes(defaultBaseURIHost).length > 0,
+            "GenArt721CoreV3_Curated: defaultBaseURIHost must be non-empty"
+        );
+
+        // input validation specific to the curated contract
+        require(
+            !engineConfiguration.autoApproveArtistSplitProposals,
+            "GenArt721CoreV3_Curated: autoApproveArtistSplitProposals must be false"
+        );
+        // @dev artblocks is listed as render provider, no party should be platform provider
+        require(
+            engineConfiguration.nullPlatformProvider,
+            "GenArt721CoreV3_Curated: nullPlatformProvider must be true"
+        );
+        require(
+            !engineConfiguration.allowArtistProjectActivation,
+            "GenArt721CoreV3_Curated: allowArtistProjectActivation must be false"
+        );
+        // @dev previous artblocks contracts exists, so only starting project ID > 0
+        require(
+            engineConfiguration.startingProjectId > 0,
+            "GenArt721CoreV3_Curated: startingProjectId must be greater than 0"
+        );
+
+        // initialize the contract
+        _initialize({
+            engineConfiguration: engineConfiguration,
+            adminACLContract_: adminACLContract_,
+            defaultBaseURIHost: defaultBaseURIHost,
+            bytecodeStorageReaderContract_: bytecodeStorageReaderContract_
+        });
+
+        // override default base URI to be curated format instead of Engine (no address required for curated)
+        _updateDefaultBaseURI(defaultBaseURIHost);
+    }
+
+    /**
+     * @notice Override of the Engine contract's initialize function.
+     * Immediately reverts, as initialization of this Curated contract is performed in the constructor.
+     */
+    function initialize(
+        EngineConfiguration memory /*engineConfiguration*/,
+        address /*adminACLContract_*/,
+        string memory /*defaultBaseURIHost*/,
+        address /*bytecodeStorageReaderContract_*/
+    ) external pure override {
+        // revert - initialization for this contract is performed in the constructor
+        // @dev note that the initialize function would revert without this override, but it is included for clarity
+        revert("GenArt721CoreV3_Curated: contract initialized in constructor");
+    }
+
+    /**
+     * @notice Updates reference to Art Blocks Curation Registry contract.
+     * @param _artblocksCurationRegistryAddress Address of Art Blocks Curation Registry contract.
+     */
+    function updateArtblocksCurationRegistryAddress(
+        address _artblocksCurationRegistryAddress
+    ) external {
+        _onlyAdminACL(this.updateArtblocksCurationRegistryAddress.selector);
+        artblocksCurationRegistryAddress = _artblocksCurationRegistryAddress;
+        emit ArtBlocksCurationRegistryContractUpdated(
+            _artblocksCurationRegistryAddress
+        );
+    }
+}