@artblocks/contracts 1.2.0 → 1.3.0

package/contracts/libs/integration-refs/delegation-registry/libraries/RegistryHashes.sol

@@ -0,0 +1,359 @@
+// SPDX-License-Identifier: CC0-1.0
+pragma solidity ^0.8.21;
+
+import {IDelegateRegistry} from "../../../../interfaces/v0.8.x/IDelegateRegistry.sol";
+
+/**
+ * @title Library for calculating the hashes and storage locations used in the delegate registry
+ *
+ * The encoding for the 5 types of delegate registry hashes should be as follows:
+ *
+ * ALL:         keccak256(abi.encodePacked(rights, from, to))
+ * CONTRACT:    keccak256(abi.encodePacked(rights, from, to, contract_))
+ * ERC721:      keccak256(abi.encodePacked(rights, from, to, contract_, tokenId))
+ * ERC20:       keccak256(abi.encodePacked(rights, from, to, contract_))
+ * ERC1155:     keccak256(abi.encodePacked(rights, from, to, contract_, tokenId))
+ *
+ * To avoid collisions between the hashes with respect to type, the hash is shifted left by one byte
+ * and the last byte is then encoded with a unique number for the delegation type
+ *
+ */
+library RegistryHashes {
+    /// @dev Used to delete everything but the last byte of a 32 byte word with and(word, EXTRACT_LAST_BYTE)
+    uint256 internal constant EXTRACT_LAST_BYTE = 0xff;
+    /// @dev Constants for the delegate registry delegation type enumeration
+    uint256 internal constant ALL_TYPE = 1;
+    uint256 internal constant CONTRACT_TYPE = 2;
+    uint256 internal constant ERC721_TYPE = 3;
+    uint256 internal constant ERC20_TYPE = 4;
+    uint256 internal constant ERC1155_TYPE = 5;
+    /// @dev Constant for the location of the delegations array in the delegate registry, defined to be zero
+    uint256 internal constant DELEGATION_SLOT = 0;
+
+    /**
+     * @notice Helper function to decode last byte of a delegation hash into its delegation type enum
+     * @param inputHash The bytehash to decode the type from
+     * @return decodedType The delegation type
+     */
+    function decodeType(
+        bytes32 inputHash
+    ) internal pure returns (IDelegateRegistry.DelegationType decodedType) {
+        assembly {
+            decodedType := and(inputHash, EXTRACT_LAST_BYTE)
+        }
+    }
+
+    /**
+     * @notice Helper function that computes the storage location of a particular delegation array
+     * @dev Storage keys further down the array can be obtained by adding computedLocation with the element position
+     * @dev Follows the solidity storage location encoding for a mapping(bytes32 => fixedArray) at the position of the delegationSlot
+     * @param inputHash The bytehash to decode the type from
+     * @return computedLocation is the storage key of the delegation array at position 0
+     */
+    function location(
+        bytes32 inputHash
+    ) internal pure returns (bytes32 computedLocation) {
+        assembly ("memory-safe") {
+            // This block only allocates memory in the scratch space
+            mstore(0, inputHash)
+            mstore(32, DELEGATION_SLOT)
+            computedLocation := keccak256(0, 64) // Run keccak256 over bytes in scratch space to obtain the storage key
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation hash for `DelegationType.ALL`
+     * @dev Equivalent to `keccak256(abi.encodePacked(rights, from, to))` then left-shift by 1 byte and write the delegation type to the cleaned last byte
+     * @dev Will not revert if `from` or `to` are > uint160, any input larger than uint160 for `from` and `to` will be cleaned to its lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @return hash The delegation parameters encoded with ALL_TYPE
+     */
+    function allHash(
+        address from,
+        bytes32 rights,
+        address to
+    ) internal pure returns (bytes32 hash) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer
+            let ptr := mload(64) // Load the free memory pointer
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            hash := or(shl(8, keccak256(ptr, 72)), ALL_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation location for `DelegationType.ALL`
+     * @dev Equivalent to `location(allHash(rights, from, to))`
+     * @dev Will not revert if `from` or `to` are > uint160, any input larger than uint160 for `from` and `to` will be cleaned to its lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @return computedLocation The storage location of the all delegation with those parameters in the delegations mapping
+     */
+    function allLocation(
+        address from,
+        bytes32 rights,
+        address to
+    ) internal pure returns (bytes32 computedLocation) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer and in the scratch space
+            let ptr := mload(64) // Load the free memory pointer
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            mstore(0, or(shl(8, keccak256(ptr, 72)), ALL_TYPE)) // Computes `allHash`, then stores the result in scratch space
+            mstore(32, DELEGATION_SLOT)
+            computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation hash for `DelegationType.CONTRACT`
+     * @dev Equivalent to keccak256(abi.encodePacked(rights, from, to, contract_)) left-shifted by 1 then last byte overwritten with CONTRACT_TYPE
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param contract_ The address of the contract specified by the delegation
+     * @return hash The delegation parameters encoded with CONTRACT_TYPE
+     */
+    function contractHash(
+        address from,
+        bytes32 rights,
+        address to,
+        address contract_
+    ) internal pure returns (bytes32 hash) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer
+            let ptr := mload(64) // Load the free memory pointer
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            hash := or(shl(8, keccak256(ptr, 92)), CONTRACT_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation location for `DelegationType.CONTRACT`
+     * @dev Equivalent to `location(contractHash(rights, from, to, contract_))`
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param contract_ The address of the contract specified by the delegation
+     * @return computedLocation The storage location of the contract delegation with those parameters in the delegations mapping
+     */
+    function contractLocation(
+        address from,
+        bytes32 rights,
+        address to,
+        address contract_
+    ) internal pure returns (bytes32 computedLocation) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer and in the scratch space
+            let ptr := mload(64) // Load free memory pointer
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            mstore(0, or(shl(8, keccak256(ptr, 92)), CONTRACT_TYPE)) // Computes `contractHash`, then stores the result in scratch space
+            mstore(32, DELEGATION_SLOT)
+            computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation hash for `DelegationType.ERC721`
+     * @dev Equivalent to `keccak256(abi.encodePacked(rights, from, to, contract_, tokenId)) left-shifted by 1 then last byte overwritten with ERC721_TYPE
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param tokenId The id of the token specified by the delegation
+     * @param contract_ The address of the contract specified by the delegation
+     * @return hash The delegation parameters encoded with ERC721_TYPE
+     */
+    function erc721Hash(
+        address from,
+        bytes32 rights,
+        address to,
+        uint256 tokenId,
+        address contract_
+    ) internal pure returns (bytes32 hash) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer
+            let ptr := mload(64) // Cache the free memory pointer.
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 92), tokenId)
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            hash := or(shl(8, keccak256(ptr, 124)), ERC721_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation location for `DelegationType.ERC721`
+     * @dev Equivalent to `location(ERC721Hash(rights, from, to, contract_, tokenId))`
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param tokenId The id of the ERC721 token
+     * @param contract_ The address of the ERC721 token contract
+     * @return computedLocation The storage location of the ERC721 delegation with those parameters in the delegations mapping
+     */
+    function erc721Location(
+        address from,
+        bytes32 rights,
+        address to,
+        uint256 tokenId,
+        address contract_
+    ) internal pure returns (bytes32 computedLocation) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer and in the scratch space
+            let ptr := mload(64) // Cache the free memory pointer.
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 92), tokenId)
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            mstore(0, or(shl(8, keccak256(ptr, 124)), ERC721_TYPE)) // Computes erc721Hash, then stores the result in scratch space
+            mstore(32, DELEGATION_SLOT)
+            computedLocation := keccak256(0, 64) // Runs keccak256 over the scratch space to obtain the storage key
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation hash for `DelegationType.ERC20`
+     * @dev Equivalent to `keccak256(abi.encodePacked(rights, from, to, contract_))` with the last byte overwritten with ERC20_TYPE
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param contract_ The address of the ERC20 token contract
+     * @return hash The parameters encoded with ERC20_TYPE
+     */
+    function erc20Hash(
+        address from,
+        bytes32 rights,
+        address to,
+        address contract_
+    ) internal pure returns (bytes32 hash) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer
+            let ptr := mload(64) // Load free memory pointer
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            hash := or(shl(8, keccak256(ptr, 92)), ERC20_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation location for `DelegationType.ERC20`
+     * @dev Equivalent to `location(ERC20Hash(rights, from, to, contract_))`
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param contract_ The address of the ERC20 token contract
+     * @return computedLocation The storage location of the ERC20 delegation with those parameters in the delegations mapping
+     */
+    function erc20Location(
+        address from,
+        bytes32 rights,
+        address to,
+        address contract_
+    ) internal pure returns (bytes32 computedLocation) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer and in the scratch space
+            let ptr := mload(64) // Loads the free memory pointer
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            mstore(0, or(shl(8, keccak256(ptr, 92)), ERC20_TYPE)) // Computes erc20Hash, then stores the result in scratch space
+            mstore(32, DELEGATION_SLOT)
+            computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation hash for `DelegationType.ERC1155`
+     * @dev Equivalent to keccak256(abi.encodePacked(rights, from, to, contract_, tokenId)) left-shifted with the last byte overwritten with ERC1155_TYPE
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param tokenId The id of the ERC1155 token
+     * @param contract_ The address of the ERC1155 token contract
+     * @return hash The parameters encoded with ERC1155_TYPE
+     */
+    function erc1155Hash(
+        address from,
+        bytes32 rights,
+        address to,
+        uint256 tokenId,
+        address contract_
+    ) internal pure returns (bytes32 hash) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer
+            let ptr := mload(64) // Load the free memory pointer.
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 92), tokenId)
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            hash := or(shl(8, keccak256(ptr, 124)), ERC1155_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte
+        }
+    }
+
+    /**
+     * @notice Helper function to compute delegation location for `DelegationType.ERC1155`
+     * @dev Equivalent to `location(ERC1155Hash(rights, from, to, contract_, tokenId))`
+     * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes
+     * @param from The address making the delegation
+     * @param rights The rights specified by the delegation
+     * @param to The address receiving the delegation
+     * @param tokenId The id of the ERC1155 token
+     * @param contract_ The address of the ERC1155 token contract
+     * @return computedLocation The storage location of the ERC1155 delegation with those parameters in the delegations mapping
+     */
+    function erc1155Location(
+        address from,
+        bytes32 rights,
+        address to,
+        uint256 tokenId,
+        address contract_
+    ) internal pure returns (bytes32 computedLocation) {
+        assembly ("memory-safe") {
+            // This block only allocates memory after the free memory pointer and in the scratch space
+            let ptr := mload(64) // Cache the free memory pointer.
+            // Lay out the variables from last to first, agnostic to upper 96 bits of address words.
+            mstore(add(ptr, 92), tokenId)
+            mstore(add(ptr, 60), contract_)
+            mstore(add(ptr, 40), to)
+            mstore(add(ptr, 20), from)
+            mstore(ptr, rights)
+            mstore(0, or(shl(8, keccak256(ptr, 124)), ERC1155_TYPE)) // Computes erc1155Hash, then stores the result in scratch space
+            mstore(32, DELEGATION_SLOT)
+            computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key
+        }
+    }
+}

package/contracts/libs/integration-refs/delegation-registry/libraries/RegistryOps.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: CC0-1.0
+pragma solidity ^0.8.21;
+
+library RegistryOps {
+    /// @dev `x > y ? x : y`.
+    function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
+        assembly {
+            // `gt(y, x)` will evaluate to 1 if `y > x`, else 0.
+            //
+            // If `y > x`:
+            //     `x ^ ((x ^ y) * 1) = x ^ (x ^ y) = (x ^ x) ^ y = 0 ^ y = y`.
+            // otherwise:
+            //     `x ^ ((x ^ y) * 0) = x ^ 0 = x`.
+            z := xor(x, mul(xor(x, y), gt(y, x)))
+        }
+    }
+
+    /// @dev `x & y`.
+    function and(bool x, bool y) internal pure returns (bool z) {
+        assembly {
+            z := and(iszero(iszero(x)), iszero(iszero(y))) // Compiler cleans dirty booleans on the stack to 1, so do the same here
+        }
+    }
+
+    /// @dev `x | y`.
+    function or(bool x, bool y) internal pure returns (bool z) {
+        assembly {
+            z := or(iszero(iszero(x)), iszero(iszero(y))) // Compiler cleans dirty booleans on the stack to 1, so do the same here
+        }
+    }
+}

package/contracts/libs/integration-refs/delegation-registry/libraries/RegistryStorage.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: CC0-1.0
+pragma solidity ^0.8.21;
+
+library RegistryStorage {
+    /// @dev Standardizes `from` storage flags to prevent double-writes in the delegation in/outbox if the same delegation is revoked and rewritten
+    address internal constant DELEGATION_EMPTY = address(0);
+    address internal constant DELEGATION_REVOKED = address(1);
+
+    /// @dev Standardizes storage positions of delegation data
+    uint256 internal constant POSITIONS_FIRST_PACKED = 0; //  | 4 bytes empty | first 8 bytes of contract address | 20 bytes of from address |
+    uint256 internal constant POSITIONS_SECOND_PACKED = 1; // |        last 12 bytes of contract address          | 20 bytes of to address   |
+    uint256 internal constant POSITIONS_RIGHTS = 2;
+    uint256 internal constant POSITIONS_TOKEN_ID = 3;
+    uint256 internal constant POSITIONS_AMOUNT = 4;
+
+    /// @dev Used to clean address types of dirty bits with `and(address, CLEAN_ADDRESS)`
+    uint256 internal constant CLEAN_ADDRESS =
+        0x00ffffffffffffffffffffffffffffffffffffffff;
+
+    /// @dev Used to clean everything but the first 8 bytes of an address
+    uint256 internal constant CLEAN_FIRST8_BYTES_ADDRESS =
+        0xffffffffffffffff << 96;
+
+    /// @dev Used to clean everything but the first 8 bytes of an address in the packed position
+    uint256 internal constant CLEAN_PACKED8_BYTES_ADDRESS =
+        0xffffffffffffffff << 160;
+
+    /**
+     * @notice Helper function that packs from, to, and contract_ address to into the two slot configuration
+     * @param from The address making the delegation
+     * @param to The address receiving the delegation
+     * @param contract_ The contract address associated with the delegation (optional)
+     * @return firstPacked The firstPacked storage configured with the parameters
+     * @return secondPacked The secondPacked storage configured with the parameters
+     * @dev Will not revert if `from`, `to`, and `contract_` are > uint160, any inputs with dirty bits outside the last 20 bytes will be cleaned
+     */
+    function packAddresses(
+        address from,
+        address to,
+        address contract_
+    ) internal pure returns (bytes32 firstPacked, bytes32 secondPacked) {
+        assembly {
+            firstPacked := or(
+                shl(64, and(contract_, CLEAN_FIRST8_BYTES_ADDRESS)),
+                and(from, CLEAN_ADDRESS)
+            )
+            secondPacked := or(shl(160, contract_), and(to, CLEAN_ADDRESS))
+        }
+    }
+
+    /**
+     * @notice Helper function that unpacks from, to, and contract_ address inside the firstPacked secondPacked storage configuration
+     * @param firstPacked The firstPacked storage to be decoded
+     * @param secondPacked The secondPacked storage to be decoded
+     * @return from The address making the delegation
+     * @return to The address receiving the delegation
+     * @return contract_ The contract address associated with the delegation
+     * @dev Will not revert if `from`, `to`, and `contract_` are > uint160, any inputs with dirty bits outside the last 20 bytes will be cleaned
+     */
+    function unpackAddresses(
+        bytes32 firstPacked,
+        bytes32 secondPacked
+    ) internal pure returns (address from, address to, address contract_) {
+        assembly {
+            from := and(firstPacked, CLEAN_ADDRESS)
+            to := and(secondPacked, CLEAN_ADDRESS)
+            contract_ := or(
+                shr(64, and(firstPacked, CLEAN_PACKED8_BYTES_ADDRESS)),
+                shr(160, secondPacked)
+            )
+        }
+    }
+
+    /**
+     * @notice Helper function that can unpack the from or to address from their respective packed slots in the registry
+     * @param packedSlot The slot containing the from or to address
+     * @return unpacked The `from` or `to` address
+     * @dev Will not work if you want to obtain the contract address, use unpackAddresses
+     */
+    function unpackAddress(
+        bytes32 packedSlot
+    ) internal pure returns (address unpacked) {
+        assembly {
+            unpacked := and(packedSlot, CLEAN_ADDRESS)
+        }
+    }
+}

package/contracts/libs/v0.8.x/Bytes32Strings.sol

@@ -63,4 +63,24 @@ library Bytes32Strings {
         }
         return _occurrences == targetQty;
     }
+
+    /**
+     * @notice Converts string to bytes32.
+     * https://ethereum.stackexchange.com/a/9152
+     * @param source string to be converted.
+     * @return result bytes32 representation of string.
+     * @dev If string is longer than 32 bytes, it truncates to the right.
+     */
+    function stringToBytes32(
+        string memory source
+    ) internal pure returns (bytes32 result) {
+        bytes memory tempEmptyStringTest = bytes(source);
+        if (tempEmptyStringTest.length == 0) {
+            return 0x0;
+        }
+
+        assembly ("memory-safe") {
+            result := mload(add(source, 32))
+        }
+    }
 }

package/contracts/libs/v0.8.x/DependencyRegistryStorageLib.sol

@@ -2,6 +2,8 @@
 pragma solidity ^0.8.19;
 
 import "../../interfaces/v0.8.x/IAdminACLV0.sol";
+import "../../interfaces/v0.8.x/ICoreRegistryV1.sol";
+import "../../interfaces/v0.8.x/IUniversalBytecodeStorageReader.sol";
 import "@openzeppelin-4.7/contracts/utils/structs/EnumerableSet.sol";
 
 /**
@@ -66,14 +68,23 @@ library DependencyRegistryStorageLib {
         mapping(bytes32 dependencyNameAndVersion => Dependency dependency) dependencyRecords;
         // mapping from licenseTypes to License, which stores the properties of each license
         mapping(bytes32 licenseType => License license) allLicenses;
-        // Set of addresses for the core contracts that are supported by the DependencyRegistry.
-        // Each address represents a unique core contract in the Art Blocks ecosystem.
-        EnumerableSet.AddressSet supportedCoreContracts;
+        // @dev This set is vestigial and no longer used. It has been replaced by CoreRegistry functionality.
+        // Cannot be removed due to storage layout requirements in upgradeable contracts.
+        // See https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable#modifying-your-contracts
+        EnumerableSet.AddressSet DEPRECATED_supportedCoreContracts;
         // Mapping that allows for the overriding of project dependencies.
         // The first key is the address of the core contract, the second key is the project ID,
         // and the value is the bytes32 representation of the dependency name and version (i.e. name@version).
         // This allows for specific projects to use different versions of dependencies than what's stored on the core contract.
         mapping(address coreContractAddress => mapping(uint256 projectId => bytes32 dependencyNameAndVersion) projectToDependencyNameAndVersionMapping) projectDependencyOverrides;
+        // address of the CoreRegistry contract
+        ICoreRegistryV1 coreRegistryContract;
+        // enumerable set of core contract addresses supported by the DependencyRegistry, in addition to the set of core contracts
+        // that are supported by the CoreRegistry contract
+        // @dev possible there is overlap between the two sets, but not intentionally configured by admin.
+        EnumerableSet.AddressSet supportedCoreContractsOverride;
+        // address of the UniversalBytecodeStorageReader contract
+        IUniversalBytecodeStorageReader universalReader;
     }
 
     /**