@artblocks/contracts 1.2.0 → 1.3.0

package/contracts/generator/scripty-support/Scripty.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.0;
+
+// This file is just used to make sure ScriptyBuilderV2.sol is compiled for use in tests.
+import "scripty.sol/contracts/scripty/ScriptyBuilderV2.sol";

package/contracts/interfaces/v0.8.x/IBytecodeStorageReader.sol

@@ -3,60 +3,58 @@
 
 pragma solidity ^0.8.0;
 
+import {IBytecodeStorageReader_Base} from "./IBytecodeStorageReader_Base.sol";
+
 /**
- * @title Art Blocks Script Storage Library (Reader)
- * @notice This interface defines the expected read functions for the Art Blocks Script Storage Library (Reader).
+ * @title Art Blocks Script Storage Library - Reader Contract
+ * @notice This interface defines the expected read functions for the Art Blocks Script Storage Library's Reader
+ * Contracts. It is extended from the base interface to add additional read functions for further introspection of
+ * stored data.
  */
-interface IBytecodeStorageReader {
-    /**
-     * @notice Read a string from contract bytecode
-     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
-     * @return data string read from contract bytecode
-     * @dev This function performs input validation that the contract to read is in an expected format
-     */
-    function readFromBytecode(
-        address _address
-    ) external view returns (string memory data);
-
+interface IBytecodeStorageReader is IBytecodeStorageReader_Base {
     /**
-     * @notice Read the bytes from contract bytecode that was written to the EVM using SSTORE2
-     * @param _address address of deployed contract with bytecode stored in the SSTORE2 format
-     * @return data bytes read from contract bytecode
-     * @dev This function performs no input validation on the provided contract,
-     *      other than that there is content to read (but not that its a "storage contract")
+     * @notice Read a bytes array from the SSTORE2-formatted bytecode of a contract.
+     * Note that this function is only compatible with contracts that have been deployed using the popular SSTORE2
+     * library.
+     * @dev see versioned BytecodeStorageReader implementation details to understand which data are being returned,
+     * espcially in the context of EOF updates.
+     * @param address_ address of contract with SSTORE2-formatted bytecode to be read
+     * @return data The bytes data stored at the specific address.
      */
     function readBytesFromSSTORE2Bytecode(
-        address _address
+        address address_
     ) external view returns (bytes memory data);
 
     /**
-     * @notice Read the bytes from contract bytecode, with an explicitly provided starting offset
-     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
-     * @param _offset offset to read from in contract bytecode, explicitly provided (not calculated)
-     * @return data bytes read from contract bytecode
-     * @dev This function performs no input validation on the provided contract,
-     *      other than that there is content to read (but not that its a "storage contract")
+     * @notice Read a bytes array from the a contract deployed via BytecodeStorage.
+     * @dev see versioned BytecodeStorageReader implementation details to understand which data are being returned, and
+     * how offset is interpreted, especially in the context of EOF updates.
+     * @param address_ address of contract with valid bytecode to be read
+     * @param offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return The bytes data stored at the specific address.
      */
     function readBytesFromBytecode(
-        address _address,
-        uint256 _offset
-    ) external view returns (bytes memory data);
+        address address_,
+        uint256 offset
+    ) external view returns (bytes memory);
+
+    //------ Metadata Functions ------//
 
     /**
-     * @notice Get address for deployer for given contract bytecode
-     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
-     * @return writerAddress address read from contract bytecode
+     * @notice Get address of deployer for given contract deployed via BytecodeStorage.
+     * @param address_ address of deployed contract
+     * @return writerAddress address of deployer
      */
     function getWriterAddressForBytecode(
-        address _address
+        address address_
     ) external view returns (address);
 
     /**
-     * @notice Get version for given contract bytecode
-     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
-     * @return version version read from contract bytecode
+     * @notice Get version for given contract deployed via BytecodeStorage.
+     * @param address_ address of deployed contract
+     * @return version version of the contract
      */
     function getLibraryVersionForBytecode(
-        address _address
+        address address_
     ) external view returns (bytes32);
 }

package/contracts/interfaces/v0.8.x/IBytecodeStorageReaderV2.sol

@@ -7,14 +7,16 @@ import {IBytecodeStorageReader} from "./IBytecodeStorageReader.sol";
 
 /**
  * @title Art Blocks Script Storage Library (Reader)
- * @notice This interface defines the expected read functions for the Art Blocks Script Storage Library (Reader).
+ * @notice This interface defines the expected read functions for a Bytecode Storage Reader contract.
  * @dev This interface extends the V1 interface to add a function to get if data are stored in compressed format,
  * which is functionality added in the V2 format of the bytecode storage.
  */
 interface IBytecodeStorageReaderV2 is IBytecodeStorageReader {
+    //------ Metadata Functions ------//
+
     /**
-     * @notice Get if data are stored in compressed format for given contract bytecode
-     * @param _address address of deployed contract with bytecode stored in the V0, V1, or V2 format
+     * @notice Get if data are stored in compressed format for given contract deployed via BytecodeStorage.
+     * @param _address address of deployed contract
      * @return isCompressed boolean indicating if the stored data are compressed
      */
     function getIsCompressedForBytecode(

package/contracts/interfaces/v0.8.x/IBytecodeStorageReader_Base.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Creatd By: Art Blocks Inc.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Art Blocks Script Storage Library - Minimal Interface for Reader Contracts
+ * @notice This interface defines the minimal expected read function(s) for a Bytecode Storage Reader contract.
+ */
+interface IBytecodeStorageReader_Base {
+    /**
+     * @notice Read a string from a data contract deployed via BytecodeStorage.
+     * @dev may also support reading additional stored data formats in the future.
+     * @param address_ address of contract deployed via BytecodeStorage to be read
+     * @return data The string data stored at the specific address.
+     */
+    function readFromBytecode(
+        address address_
+    ) external view returns (string memory data);
+}

package/contracts/interfaces/v0.8.x/ICoreRegistryV1.sol

@@ -22,4 +22,9 @@ interface ICoreRegistryV1 is IEngineRegistryV0 {
     function isRegisteredContract(
         address contractAddress
     ) external view returns (bool isRegistered);
+
+    function getAllRegisteredContracts()
+        external
+        view
+        returns (address[] memory);
 }

package/contracts/interfaces/v0.8.x/IDelegateRegistry.sol

@@ -0,0 +1,318 @@
+// SPDX-License-Identifier: CC0-1.0
+pragma solidity >=0.8.13;
+
+/**
+ * @title IDelegateRegistry
+ * @custom:version 2.0
+ * @custom:author foobar (0xfoobar)
+ * @notice A standalone immutable registry storing delegated permissions from one address to another
+ */
+interface IDelegateRegistry {
+    /// @notice Delegation type, NONE is used when a delegation does not exist or is revoked
+    enum DelegationType {
+        NONE,
+        ALL,
+        CONTRACT,
+        ERC721,
+        ERC20,
+        ERC1155
+    }
+
+    /// @notice Struct for returning delegations
+    struct Delegation {
+        DelegationType type_;
+        address to;
+        address from;
+        bytes32 rights;
+        address contract_;
+        uint256 tokenId;
+        uint256 amount;
+    }
+
+    /// @notice Emitted when an address delegates or revokes rights for their entire wallet
+    event DelegateAll(
+        address indexed from,
+        address indexed to,
+        bytes32 rights,
+        bool enable
+    );
+
+    /// @notice Emitted when an address delegates or revokes rights for a contract address
+    event DelegateContract(
+        address indexed from,
+        address indexed to,
+        address indexed contract_,
+        bytes32 rights,
+        bool enable
+    );
+
+    /// @notice Emitted when an address delegates or revokes rights for an ERC721 tokenId
+    event DelegateERC721(
+        address indexed from,
+        address indexed to,
+        address indexed contract_,
+        uint256 tokenId,
+        bytes32 rights,
+        bool enable
+    );
+
+    /// @notice Emitted when an address delegates or revokes rights for an amount of ERC20 tokens
+    event DelegateERC20(
+        address indexed from,
+        address indexed to,
+        address indexed contract_,
+        bytes32 rights,
+        uint256 amount
+    );
+
+    /// @notice Emitted when an address delegates or revokes rights for an amount of an ERC1155 tokenId
+    event DelegateERC1155(
+        address indexed from,
+        address indexed to,
+        address indexed contract_,
+        uint256 tokenId,
+        bytes32 rights,
+        uint256 amount
+    );
+
+    /// @notice Thrown if multicall calldata is malformed
+    error MulticallFailed();
+
+    /**
+     * -----------  WRITE -----------
+     */
+
+    /**
+     * @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
+     * @param data The encoded function data for each of the calls to make to this contract
+     * @return results The results from each of the calls passed in via data
+     */
+    function multicall(
+        bytes[] calldata data
+    ) external payable returns (bytes[] memory results);
+
+    /**
+     * @notice Allow the delegate to act on behalf of `msg.sender` for all contracts
+     * @param to The address to act as delegate
+     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
+     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
+     * @return delegationHash The unique identifier of the delegation
+     */
+    function delegateAll(
+        address to,
+        bytes32 rights,
+        bool enable
+    ) external payable returns (bytes32 delegationHash);
+
+    /**
+     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific contract
+     * @param to The address to act as delegate
+     * @param contract_ The contract whose rights are being delegated
+     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
+     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
+     * @return delegationHash The unique identifier of the delegation
+     */
+    function delegateContract(
+        address to,
+        address contract_,
+        bytes32 rights,
+        bool enable
+    ) external payable returns (bytes32 delegationHash);
+
+    /**
+     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific ERC721 token
+     * @param to The address to act as delegate
+     * @param contract_ The contract whose rights are being delegated
+     * @param tokenId The token id to delegate
+     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
+     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
+     * @return delegationHash The unique identifier of the delegation
+     */
+    function delegateERC721(
+        address to,
+        address contract_,
+        uint256 tokenId,
+        bytes32 rights,
+        bool enable
+    ) external payable returns (bytes32 delegationHash);
+
+    /**
+     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific amount of ERC20 tokens
+     * @dev The actual amount is not encoded in the hash, just the existence of a amount (since it is an upper bound)
+     * @param to The address to act as delegate
+     * @param contract_ The address for the fungible token contract
+     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
+     * @param amount The amount to delegate, > 0 delegates and 0 revokes
+     * @return delegationHash The unique identifier of the delegation
+     */
+    function delegateERC20(
+        address to,
+        address contract_,
+        bytes32 rights,
+        uint256 amount
+    ) external payable returns (bytes32 delegationHash);
+
+    /**
+     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific amount of ERC1155 tokens
+     * @dev The actual amount is not encoded in the hash, just the existence of a amount (since it is an upper bound)
+     * @param to The address to act as delegate
+     * @param contract_ The address of the contract that holds the token
+     * @param tokenId The token id to delegate
+     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
+     * @param amount The amount of that token id to delegate, > 0 delegates and 0 revokes
+     * @return delegationHash The unique identifier of the delegation
+     */
+    function delegateERC1155(
+        address to,
+        address contract_,
+        uint256 tokenId,
+        bytes32 rights,
+        uint256 amount
+    ) external payable returns (bytes32 delegationHash);
+
+    /**
+     * ----------- CHECKS -----------
+     */
+
+    /**
+     * @notice Check if `to` is a delegate of `from` for the entire wallet
+     * @param to The potential delegate address
+     * @param from The potential address who delegated rights
+     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
+     * @return valid Whether delegate is granted to act on the from's behalf
+     */
+    function checkDelegateForAll(
+        address to,
+        address from,
+        bytes32 rights
+    ) external view returns (bool);
+
+    /**
+     * @notice Check if `to` is a delegate of `from` for the specified `contract_` or the entire wallet
+     * @param to The delegated address to check
+     * @param contract_ The specific contract address being checked
+     * @param from The cold wallet who issued the delegation
+     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
+     * @return valid Whether delegate is granted to act on from's behalf for entire wallet or that specific contract
+     */
+    function checkDelegateForContract(
+        address to,
+        address from,
+        address contract_,
+        bytes32 rights
+    ) external view returns (bool);
+
+    /**
+     * @notice Check if `to` is a delegate of `from` for the specific `contract` and `tokenId`, the entire `contract_`, or the entire wallet
+     * @param to The delegated address to check
+     * @param contract_ The specific contract address being checked
+     * @param tokenId The token id for the token to delegating
+     * @param from The wallet that issued the delegation
+     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
+     * @return valid Whether delegate is granted to act on from's behalf for entire wallet, that contract, or that specific tokenId
+     */
+    function checkDelegateForERC721(
+        address to,
+        address from,
+        address contract_,
+        uint256 tokenId,
+        bytes32 rights
+    ) external view returns (bool);
+
+    /**
+     * @notice Returns the amount of ERC20 tokens the delegate is granted rights to act on the behalf of
+     * @param to The delegated address to check
+     * @param contract_ The address of the token contract
+     * @param from The cold wallet who issued the delegation
+     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
+     * @return balance The delegated balance, which will be 0 if the delegation does not exist
+     */
+    function checkDelegateForERC20(
+        address to,
+        address from,
+        address contract_,
+        bytes32 rights
+    ) external view returns (uint256);
+
+    /**
+     * @notice Returns the amount of a ERC1155 tokens the delegate is granted rights to act on the behalf of
+     * @param to The delegated address to check
+     * @param contract_ The address of the token contract
+     * @param tokenId The token id to check the delegated amount of
+     * @param from The cold wallet who issued the delegation
+     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
+     * @return balance The delegated balance, which will be 0 if the delegation does not exist
+     */
+    function checkDelegateForERC1155(
+        address to,
+        address from,
+        address contract_,
+        uint256 tokenId,
+        bytes32 rights
+    ) external view returns (uint256);
+
+    /**
+     * ----------- ENUMERATIONS -----------
+     */
+
+    /**
+     * @notice Returns all enabled delegations a given delegate has received
+     * @param to The address to retrieve delegations for
+     * @return delegations Array of Delegation structs
+     */
+    function getIncomingDelegations(
+        address to
+    ) external view returns (Delegation[] memory delegations);
+
+    /**
+     * @notice Returns all enabled delegations an address has given out
+     * @param from The address to retrieve delegations for
+     * @return delegations Array of Delegation structs
+     */
+    function getOutgoingDelegations(
+        address from
+    ) external view returns (Delegation[] memory delegations);
+
+    /**
+     * @notice Returns all hashes associated with enabled delegations an address has received
+     * @param to The address to retrieve incoming delegation hashes for
+     * @return delegationHashes Array of delegation hashes
+     */
+    function getIncomingDelegationHashes(
+        address to
+    ) external view returns (bytes32[] memory delegationHashes);
+
+    /**
+     * @notice Returns all hashes associated with enabled delegations an address has given out
+     * @param from The address to retrieve outgoing delegation hashes for
+     * @return delegationHashes Array of delegation hashes
+     */
+    function getOutgoingDelegationHashes(
+        address from
+    ) external view returns (bytes32[] memory delegationHashes);
+
+    /**
+     * @notice Returns the delegations for a given array of delegation hashes
+     * @param delegationHashes is an array of hashes that correspond to delegations
+     * @return delegations Array of Delegation structs, return empty structs for nonexistent or revoked delegations
+     */
+    function getDelegationsFromHashes(
+        bytes32[] calldata delegationHashes
+    ) external view returns (Delegation[] memory delegations);
+
+    /**
+     * ----------- STORAGE ACCESS -----------
+     */
+
+    /**
+     * @notice Allows external contracts to read arbitrary storage slots
+     */
+    function readSlot(bytes32 location) external view returns (bytes32);
+
+    /**
+     * @notice Allows external contracts to read an arbitrary array of storage slots
+     */
+    function readSlots(
+        bytes32[] calldata locations
+    ) external view returns (bytes32[] memory);
+}

package/contracts/interfaces/v0.8.x/IDependencyRegistryV0.sol

@@ -3,10 +3,22 @@
 pragma solidity ^0.8.19;
 
 interface IDependencyRegistryV0 {
+    // legacy event used before deferring to core registry for allowlist
     event SupportedCoreContractAdded(address indexed coreContractAddress);
 
+    // legacy event used before deferring to core registry for allowlist
     event SupportedCoreContractRemoved(address indexed coreContractAddress);
 
+    // active event used to add additional supported contracts beyond what core registry allows
+    event SupportedCoreContractOverrideAdded(
+        address indexed coreContractAddress
+    );
+
+    // active event used to remove additional supported contracts beyond what core registry allows
+    event SupportedCoreContractOverrideRemoved(
+        address indexed coreContractAddress
+    );
+
     event ProjectDependencyOverrideAdded(
         address indexed coreContractAddress,
         uint256 indexed projectId,
@@ -71,6 +83,10 @@ interface IDependencyRegistryV0 {
 
     event DependencyScriptUpdated(bytes32 indexed dependencyNameAndVersion);
 
+    event CoreRegistryAddressUpdated(address indexed coreRegistryAddress);
+
+    event UniversalBytecodeStorageReaderUpdated(address indexed newReader);
+
     /**
      * @notice Returns the count of scripts for dependency `dependencyNameAndVersion`.
      * @param dependencyNameAndVersion Dependency type to be queried.
@@ -97,4 +113,84 @@ interface IDependencyRegistryV0 {
         bytes32 dependencyNameAndVersion,
         uint256 index
     ) external view returns (string memory);
+
+    /**
+     * @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
+    )
+        external
+        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
+        );
+
+    /**
+     * @notice Returns the dependency name and version for a given project (`projectId`)
+     * on a given core contract (`_contractAddress`). If no override is set,
+     * the core contract is called to retrieve the script type and version as
+     * dependency type. For any contract earlier than v3, that does not have
+     * an override set, this will revert.
+     * @param contractAddress Core contract address.
+     * @param projectId Project to return dependency type for.
+     * @return dependencyType Identifier for the dependency (i.e. "name@version") used by project.
+     */
+    function getDependencyNameAndVersionForProject(
+        address contractAddress,
+        uint256 projectId
+    ) external view returns (string memory);
+
+    /**
+     * @notice Returns whether the given contract address is a supported core contract.
+     * @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);
+
+    /**
+     * @notice Convenience function that returns whether `_sender` is allowed
+     * to call function with selector `_selector` on contract `_contract`, as
+     * determined by this contract's current Admin ACL contract. Expected use
+     * cases include minter contracts checking if caller is allowed to call
+     * admin-gated functions on minter contracts.
+     * @param sender Address of the sender calling function with selector
+     * `selector` on contract `contract_`.
+     * @param contract_ Address of the contract being called by `sender`.
+     * @param selector Function selector of the function being called by
+     * `sender`.
+     * @return bool Whether `sender` is allowed to call function with selector
+     * `selector` on contract `contract_`.
+     * @dev assumes the Admin ACL contract is the owner of this contract, which
+     * is expected to always be true.
+     * @dev adminACLContract is expected to either be null address (if owner
+     * has renounced ownership), or conform to IAdminACLV0 interface. Check for
+     * null address first to avoid revert when admin has renounced ownership.
+     */
+    function adminACLAllowed(
+        address sender,
+        address contract_,
+        bytes4 selector
+    ) external returns (bool);
 }

package/contracts/interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol

@@ -4,6 +4,7 @@
 pragma solidity ^0.8.0;
 
 import "./IAdminACLV0.sol";
+import "./IGenArt721CoreProjectScriptV1.sol";
 
 /**
  * @title This interface is intended to house interface items that are common
@@ -12,7 +13,7 @@ import "./IAdminACLV0.sol";
  * add support the Royalty Registry by default.
  * @author Art Blocks Inc.
  */
-interface IGenArt721CoreContractV3_Base {
+interface IGenArt721CoreContractV3_Base is IGenArt721CoreProjectScriptV1 {
     // This interface emits generic events that contain fields that indicate
     // which parameter has been updated. This is sufficient for application
     // state management, while also simplifying the contract and indexing code.
@@ -21,6 +22,15 @@ interface IGenArt721CoreContractV3_Base {
     // be introspected by indexers due to the design of this smart contract
     // exposing these state changes via publicly viewable fields.
 
+    /**
+     * @notice Event emitted when the Art Blocks Curation Registry contract is updated.
+     * @dev only utilized by subset of V3 core contracts (Art Blocks Curated contracts)
+     * @param artblocksCurationRegistryAddress Address of Art Blocks Curation Registry contract.
+     */
+    event ArtBlocksCurationRegistryContractUpdated(
+        address indexed artblocksCurationRegistryAddress
+    );
+
     /**
      * @notice Project's royalty splitter was updated to `_splitter`.
      * @dev New event in v3.2
@@ -46,7 +56,8 @@ interface IGenArt721CoreContractV3_Base {
         FIELD_PROVIDER_SALES_ADDRESSES, // 7
         FIELD_PROVIDER_PRIMARY_SALES_PERCENTAGES, // 8
         FIELD_PROVIDER_SECONDARY_SALES_BPS, // 9
-        FIELD_SPLIT_PROVIDER // 10
+        FIELD_SPLIT_PROVIDER, // 10
+        FIELD_BYTECODE_STORAGE_READER // 11
     }
 
     // The following fields are used to indicate which project-level parameter

package/contracts/interfaces/v0.8.x/IGenArt721CoreContractV3_Engine.sol

@@ -51,11 +51,13 @@ interface IGenArt721CoreContractV3_Engine is IGenArt721CoreContractV3_Base {
      * @param adminACLContract_ Address of admin access control contract, to be
      * set as contract owner.
      * @param defaultBaseURIHost Base URI prefix to initialize default base URI with.
+     * @param bytecodeStorageReaderContract_ Address of the bytecode storage reader contract.
      */
     function initialize(
         EngineConfiguration calldata engineConfiguration,
         address adminACLContract_,
-        string memory defaultBaseURIHost
+        string memory defaultBaseURIHost,
+        address bytecodeStorageReaderContract_
     ) external;
 
     // @dev new function in V3

package/contracts/interfaces/v0.8.x/IGenArt721CoreProjectScriptV0.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This interface is implemented by GenArt721CoreV0, GenArt721CoreV1, and GenArt721CoreV2
+ */
+interface IGenArt721CoreProjectScriptV0 {
+    function projectScriptByIndex(
+        uint256 _projectId,
+        uint256 _index
+    ) external view returns (string memory);
+
+    /**
+     * @dev the return specified here is common across all
+     * pre-v3 core contracts. They all return additional
+     * data as well that varies between contracts but is not
+     * used by the dependency registry.
+     */
+    function projectScriptInfo(
+        uint256 _projectId
+    ) external view returns (string memory scriptJSON, uint256 scriptCount);
+}