@artblocks/contracts 1.2.1 → 1.3.0

package/artifacts/contracts/web3call/configure-hooks/abstractPMPConfigureHook.sol/AbstractPMPConfigureHook.json

@@ -0,0 +1,80 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "AbstractPMPConfigureHook",
+  "sourceName": "contracts/web3call/configure-hooks/abstractPMPConfigureHook.sol",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "coreContract",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "tokenId",
+          "type": "uint256"
+        },
+        {
+          "components": [
+            {
+              "internalType": "string",
+              "name": "key",
+              "type": "string"
+            },
+            {
+              "internalType": "enum IPMPV0.ParamType",
+              "name": "configuredParamType",
+              "type": "uint8"
+            },
+            {
+              "internalType": "bytes32",
+              "name": "configuredValue",
+              "type": "bytes32"
+            },
+            {
+              "internalType": "bool",
+              "name": "configuringArtistString",
+              "type": "bool"
+            },
+            {
+              "internalType": "string",
+              "name": "configuredValueString",
+              "type": "string"
+            }
+          ],
+          "internalType": "struct IPMPV0.PMPInput",
+          "name": "pmpInput",
+          "type": "tuple"
+        }
+      ],
+      "name": "onTokenPMPConfigure",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes4",
+          "name": "interfaceId",
+          "type": "bytes4"
+        }
+      ],
+      "name": "supportsInterface",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x",
+  "deployedBytecode": "0x",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/BytecodeStorageReaders/BytecodeStorageReaderContractV2_Web3Call.sol

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.22;
+
+// Created By: Art Blocks Inc.
+
+import {IBytecodeStorageReaderV2} from "../interfaces/v0.8.x/IBytecodeStorageReaderV2.sol";
+import {IWeb3Call} from "../interfaces/v0.8.x/IWeb3Call.sol";
+
+import {BytecodeStorageReader} from "../libs/v0.8.x/BytecodeStorageV2.sol";
+
+import {ERC165Checker} from "@openzeppelin-5.0/contracts/utils/introspection/ERC165Checker.sol";
+
+/**
+ * @title Art Blocks Bytecode Storage Reader Contract V2 w/ Web3Call Support
+ * @author Art Blocks Inc.
+ * @notice This contract is used to read the bytecode of a contract deployed by Art Blocks' BytecodeStorage library,
+ * for versions 0, 1, and 2 of the Art Blocks BytecodeStorage library.
+ * It includes support for returning the special string "#web3call_contract#" when reading a non-bytecode storage
+ * contract that does indicate ERC165 support for the IWeb3Call interface, enabling backwards-compatibility with
+ * Web3Call-based projects on exiting Art Blocks contracts. This only affects the readFromBytecode function.
+ * It is permissionless and can be used by anyone to read the bytecode of any contract deployed by Art Blocks.
+ * Future versions of BytecodeStorage will not be compatible with this reader.
+ * For a single location to read current and future versions of the Art Blocks BytecodeStorage library, see
+ * the UniversalBytecodeStorageReader contract, maintained by the Art Blocks team.
+ * Additional functionality is provided to read bytes data stored using the SSTORE2 library.
+ * This contract also provides an interface to read additional metadata stored by the Art Blocks BytecodeStorage
+ * library, such as the contract's version, deployer, and other metadata.
+ * @dev For simplicity and reduce code changes, this contract uses the BytecodeStorageReader external library to
+ * perform many operations. Future reader contract versions may choose to make the library internal to this contract to
+ * improve read operation performance.
+ */
+contract BytecodeStorageReaderContractV2_Web3Call is IBytecodeStorageReaderV2 {
+    using BytecodeStorageReader for address;
+
+    string public constant VERSION = "BytecodeStorageReaderContractV2_Web3Call";
+
+    /**
+     * @notice Read a string from a data contract deployed via BytecodeStorage V2 or earlier.
+     * Also supports returning "#web3call_contract#" when the contract is not a
+     * BytecodeStorage contract, but does support the IWeb3Call interface.
+     * Reverts if the contract is not a BytecodeStorage contract and does not indicate
+     * ERC165 support for the IWeb3Call interface.
+     * @param address_ address of contract deployed via BytecodeStorage to be read
+     * @return The string data stored at the specific address.
+     */
+    function readFromBytecode(
+        address address_
+    ) external view returns (string memory) {
+        try address_.readFromBytecode() returns (string memory data) {
+            return data;
+        } catch {
+            if (
+                ERC165Checker.supportsInterface(
+                    address_,
+                    type(IWeb3Call).interfaceId
+                )
+            ) {
+                return "#web3call_contract#";
+            }
+        }
+        // reading from bytecode failed, and does not indicate Web3Call support, so revert
+        revert(
+            "BytecodeStorageReaderContractV2_Web3Call: Failed to read from bytecode"
+        );
+    }
+
+    /**
+     * @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.
+     * @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_
+    ) external view returns (bytes memory) {
+        return address_.readBytesFromSSTORE2Bytecode();
+    }
+
+    /**
+     * @notice Read a bytes array from the a contract deployed via BytecodeStorage V2 or earlier.
+     * @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) {
+        return address_.readBytesFromBytecode(offset);
+    }
+
+    //------ Metadata Functions ------//
+
+    /**
+     * @notice Get address of deployer for given contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of deployed contract
+     * @return writerAddress address of deployer
+     */
+    function getWriterAddressForBytecode(
+        address address_
+    ) external view returns (address) {
+        return address_.getWriterAddressForBytecode();
+    }
+
+    /**
+     * @notice Get version for given contract deployed via BytecodeStorage V2 or earlier.
+     * @param address_ address of deployed contract
+     * @return version version of the contract
+     */
+    function getLibraryVersionForBytecode(
+        address address_
+    ) external view returns (bytes32) {
+        return address_.getLibraryVersionForBytecode();
+    }
+
+    /**
+     * @notice Get if data are stored in compressed format for given contract deployed via BytecodeStorage V2 or
+     * earlier.
+     * @param _address address of deployed contract
+     * @return isCompressed boolean indicating if the stored data are compressed
+     */
+    function getIsCompressedForBytecode(
+        address _address
+    ) external view returns (bool) {
+        return _address.getIsCompressedForBytecode();
+    }
+}

package/contracts/DependencyRegistryV0.sol

@@ -7,6 +7,8 @@ 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";
@@ -15,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";
 
 /**
@@ -112,6 +114,15 @@ 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.
@@ -969,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);
     }
 
     /**
@@ -1250,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]
+                );
     }
 
     /**
@@ -1279,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);
     }
 
     /**
@@ -1329,6 +1319,14 @@ 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.
@@ -1463,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/engine/V3/GenArt721CoreV3_Engine_Flex.sol

@@ -527,6 +527,8 @@ contract GenArt721CoreV3_Engine_Flex is
      * @notice Updates external asset dependency for project `_projectId` at
      * index `_index`, with data at BytecodeStorage-compatible address
      * `_assetAddress`.
+     * @dev This function may point to any BytecodeStorageReader-compatible
+     * on-chain asset, including a web3call contract.
      * @param _projectId Project to be updated.
      * @param _index Asset index.
      * @param _assetAddress Address of the on-chain asset.
@@ -624,6 +626,8 @@ contract GenArt721CoreV3_Engine_Flex is
      * @notice Adds an on-chain external asset dependency for project
      * `_projectId`, with data at BytecodeStorage-compatible address
      * `_assetAddress`.
+     * @dev This function may point to any BytecodeStorageReader-compatible
+     * on-chain asset, including a web3call contract.
      * @param _projectId Project to be updated.
      * @param _assetAddress Address of the BytecodeStorageReader-compatible on-chain asset.
      */
@@ -2289,9 +2293,11 @@ contract GenArt721CoreV3_Engine_Flex is
 
     /**
      * @notice Returns external asset dependency for project `_projectId` at index `_index`.
-     * If the dependencyType is ONCHAIN, the `data` field will contain the extrated bytecode data and `cid`
+     * If the dependencyType is ONCHAIN, the `data` field will contain the read BytecodeStorage data and `cid`
      * will be an empty string. Conversly, for any other dependencyType, the `data` field will be an empty string
      * and the `bytecodeAddress` will point to the zero address.
+     * @dev If an ONCHAIN dependency is a web3call, the `data` field will be returned per the BytecodeStorageReader
+     * contract's active spec, which at the time of this writing is the special string "#web3call_contract#".
      * If the dependencyType is ART_BLOCKS_DEPENDENCY_REGISTRY, the `cid` field will contain the string
      * representation of the dependencyNameAndVersion bytes32 value stored in the dependency registry (
      * at public address `artblocksDependencyRegistryAddress`)

package/contracts/generator/GenArt721GeneratorV0.sol

@@ -9,11 +9,14 @@ import "../interfaces/v0.8.x/IGenArt721CoreTokenHashProviderV1.sol";
 import "../interfaces/v0.8.x/IGenArt721GeneratorV0.sol";
 import {IGenArt721CoreContractV3_Engine_Flex} from "../interfaces/v0.8.x/IGenArt721CoreContractV3_Engine_Flex.sol";
 import {IUniversalBytecodeStorageReader} from "../interfaces/v0.8.x/IUniversalBytecodeStorageReader.sol";
+import {IWeb3Call} from "../interfaces/v0.8.x/IWeb3Call.sol";
+
 import "../libs/v0.8.x/Bytes32Strings.sol";
 import {JsonStatic} from "../libs/v0.8.x/JsonStatic.sol";
 import {ABHelpers} from "../libs/v0.8.x/ABHelpers.sol";
 import {AddressChunks} from "./AddressChunks.sol";
 
+import {Base64} from "@openzeppelin-5.0/contracts/utils/Base64.sol";
 import "@openzeppelin-4.7/contracts/utils/Strings.sol";
 import "@openzeppelin-4.8/contracts-upgradeable/proxy/utils/Initializable.sol";
 
@@ -562,12 +565,12 @@ contract GenArt721GeneratorV0 is Initializable, IGenArt721GeneratorV0 {
      * as well as any dependency name and version if the dependency is an
      * ART_BLOCKS_DEPENDENCY_REGISTRY dependency.
      * @param coreContract The core contract address the project belongs to.
-     * @param projectId The ID of the project to retrieve the external asset dependency for.
+     * @param tokenId The ID of the token to retrieve the external asset dependency for.
      * @param index The index of the external asset dependency to retrieve.
      */
     function _getExternalAssetDependencyKeysAndValues(
         address coreContract,
-        uint256 projectId,
+        uint256 tokenId,
         uint256 index
     )
         internal
@@ -578,6 +581,8 @@ contract GenArt721GeneratorV0 is Initializable, IGenArt721GeneratorV0 {
             bytes32 /*dependencyNameAndVersion*/
         )
     {
+        // get project id from token id
+        uint256 projectId = ABHelpers.tokenIdToProjectId(tokenId);
         // default as not an art blocks dependency registry dependency
         bytes32 dependencyNameAndVersion; // default as not an art blocks dependency registry dependency
         // each external asset dependency has 3 fields, so pre-allocate array to avoid dynamic memory allocation
@@ -612,10 +617,33 @@ contract GenArt721GeneratorV0 is Initializable, IGenArt721GeneratorV0 {
                 .ExternalAssetDependencyType
                 .ONCHAIN
         ) {
-            dependencyValues[2] = JsonStatic.newStringElement({
-                value: externalAssetDependencyWithData.data, // assign data for ONCHAIN dependencies
-                stringEncodingFlag: JsonStatic.StringEncodingFlag.BASE64
-            });
+            if (
+                keccak256(
+                    abi.encodePacked(externalAssetDependencyWithData.data)
+                ) == keccak256(abi.encodePacked("#web3call_contract#")) // @dev special string indicating a web3call contract
+            ) {
+                // treat as a web3call contract, inject token parameters based on the web3call contract
+                // @dev prepend with "#web3call#" to indicate that the data should be decoded as a web3call
+                // with base64 encoded key/value pairs
+                dependencyValues[2] = JsonStatic.newStringElement({
+                    value: string.concat(
+                        "#web3call#",
+                        _getWeb3CallParameters({
+                            web3callContract: externalAssetDependencyWithData
+                                .bytecodeAddress,
+                            coreContract: coreContract,
+                            tokenId: tokenId
+                        })
+                    ),
+                    stringEncodingFlag: JsonStatic.StringEncodingFlag.NONE // we base64 encode everything in the _getWeb3CallParameters function
+                });
+            } else {
+                // @dev typical ONCHAIN dependency, assign data for ONCHAIN dependencies
+                dependencyValues[2] = JsonStatic.newStringElement({
+                    value: externalAssetDependencyWithData.data,
+                    stringEncodingFlag: JsonStatic.StringEncodingFlag.BASE64
+                });
+            }
         } else {
             dependencyValues[2] = JsonStatic.newStringElement({
                 value: "", // empty string for non-ONCHAIN dependencies
@@ -744,7 +772,7 @@ contract GenArt721GeneratorV0 is Initializable, IGenArt721GeneratorV0 {
                     bytes32 dependencyNameAndVersion
                 ) = _getExternalAssetDependencyKeysAndValues({
                         coreContract: coreContract,
-                        projectId: projectId,
+                        tokenId: tokenId,
                         index: i
                     });
                 // handle ART_BLOCKS_DEPENDENCY_REGISTRY dependency type
@@ -870,7 +898,7 @@ contract GenArt721GeneratorV0 is Initializable, IGenArt721GeneratorV0 {
         headTags[1].tagContent = abi.encodePacked(
             "let tokenData = JSON.parse(`",
             tokenDataJson,
-            '`, (key, value) => key === "data" && value !== null ? atob(value) : value);'
+            '`, (key, value) => key === "data" && value !== null ? value.startsWith("#web3call#") ? Object.entries(JSON.parse(atob(value.slice(10)))).reduce((acc, [k, v]) => ((acc[atob(k)] = atob(v)), acc), {}) : atob(value) : value);'
         );
         headTags[1].tagType = HTMLTagType.script;
         for (
@@ -997,6 +1025,47 @@ contract GenArt721GeneratorV0 is Initializable, IGenArt721GeneratorV0 {
             .getDependencyDetails(dependencyNameAndVersion);
     }
 
+    /**
+     * @dev Helper function to get the web3call parameters for a given token.
+     * Assumes the contract supports the IWeb3Call interface.
+     * @param web3callContract The address of the contract to call.
+     * @param coreContract The address of the core contract.
+     * @param tokenId The ID of the token.
+     * @return The web3call parameters for the token as a json string, keys and values encoded
+     * as base64 strings, then the entire json string is encoded as base64.
+     */
+    function _getWeb3CallParameters(
+        address web3callContract,
+        address coreContract,
+        uint256 tokenId
+    ) internal view returns (string memory) {
+        // get the onchain data for the contract
+        IWeb3Call.TokenParam[] memory tokenParams = IWeb3Call(web3callContract)
+            .getTokenParams({coreContract: coreContract, tokenId: tokenId});
+        uint256 tokenParamsLength = tokenParams.length;
+        // build key/value arrays for the token params
+        string[] memory keys = JsonStatic.newKeysArray(tokenParamsLength);
+        JsonStatic.Json[] memory values = JsonStatic.newValuesArray(
+            tokenParamsLength
+        );
+        for (uint256 i = 0; i < tokenParamsLength; i++) {
+            // @dev encode the key here as base64 string, to handle any special characters
+            IWeb3Call.TokenParam memory tokenParam = tokenParams[i];
+            keys[i] = Base64.encode(bytes(tokenParam.key));
+            values[i] = JsonStatic.newStringElement({
+                value: (tokenParam.value),
+                stringEncodingFlag: JsonStatic.StringEncodingFlag.BASE64
+            });
+        }
+        // use JsonStatic to build a printable json object from the key/value arrays
+        JsonStatic.Json memory tokenParamsJson = JsonStatic.newObjectElement({
+            keys: keys,
+            values: values
+        });
+        // @dev base64 encode the entire json object for consistent encoding of data field
+        return Base64.encode(bytes(tokenParamsJson.write()));
+    }
+
     /**
      * @dev Helper function to get a canvas tag or an empty tag depending on the dependency name.
      * @return The canvas tag or an empty tag.