@artblocks/contracts 1.2.0 → 1.2.1

package/contracts/engine/V3/GenArt721CoreV3_Engine_Flex.sol

@@ -10,12 +10,13 @@ import {IGenArt721CoreContractV3_ProjectFinance} from "../../interfaces/v0.8.x/I
 import "../../interfaces/v0.8.x/IGenArt721CoreContractExposesHashSeed.sol";
 import "../../interfaces/v0.8.x/IDependencyRegistryCompatibleV0.sol";
 import {ISplitProviderV0} from "../../interfaces/v0.8.x/ISplitProviderV0.sol";
+import {IBytecodeStorageReader_Base} from "../../interfaces/v0.8.x/IBytecodeStorageReader_Base.sol";
 
 import "@openzeppelin-5.0/contracts/utils/Strings.sol";
 import "@openzeppelin-5.0/contracts/access/Ownable.sol";
 import {IERC2981} from "@openzeppelin-5.0/contracts/interfaces/IERC2981.sol";
 import "../../libs/v0.8.x/ERC721_PackedHashSeedV1.sol";
-import "../../libs/v0.8.x/BytecodeStorageV2.sol";
+import {BytecodeStorageWriter, BytecodeStorageReader} from "../../libs/v0.8.x/BytecodeStorageV2.sol";
 import {V3FlexLib} from "../../libs/v0.8.x/V3FlexLib.sol";
 import "../../libs/v0.8.x/Bytes32Strings.sol";
 
@@ -49,6 +50,7 @@ import "../../libs/v0.8.x/Bytes32Strings.sol";
  * - forbidNewProjects (forever forbidding new projects)
  * - updateDefaultBaseURI (used to initialize new project base URIs)
  * - updateSplitProvider
+ * - updateBytecodeStorageReaderContract
  * - updateIPFSGateway
  * - updateArweaveGateway
  * ----------------------------------------------------------------------------
@@ -279,9 +281,9 @@ contract GenArt721CoreV3_Engine_Flex is
     bool public allowArtistProjectActivation;
 
     /// version & type of this core contract
-    bytes32 constant CORE_VERSION = "v3.2.3";
+    bytes32 constant CORE_VERSION = "v3.2.5";
 
-    function coreVersion() external pure returns (string memory) {
+    function coreVersion() external pure virtual returns (string memory) {
         return CORE_VERSION.toString();
     }
 
@@ -301,6 +303,9 @@ contract GenArt721CoreV3_Engine_Flex is
     // royalty split provider
     ISplitProviderV0 public splitProvider;
 
+    // bytecode storage reader contract; may be universal or specific version reader contract
+    IBytecodeStorageReader_Base public bytecodeStorageReaderContract;
+
     /**
      * @dev This constructor sets the owner to a non-functional address as a formality.
      * It is only ever ran on the implementation contract. The `Ownable` constructor is
@@ -409,77 +414,25 @@ contract GenArt721CoreV3_Engine_Flex is
      * function will be called atomically by the factory contract that deploys this
      * contract, after which it will be initialized and uncallable.
      * @param engineConfiguration EngineConfiguration to configure the contract with.
+     * note: parameter `engineConfiguration.newSuperAdminAddress` is not used or operated on in this contract.
      * @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,
+        EngineConfiguration memory engineConfiguration,
         address adminACLContract_,
-        string memory defaultBaseURIHost
-    ) external {
-        // can only be initialized once
-        if (_initialized) {
-            revert GenArt721Error(ErrorCodes.ContractInitialized);
-        }
-        // immediately mark as initialized
-        _initialized = true;
-        // @dev assume renderProviderAddress, randomizer, and AdminACL non-zero
-        // checks on platform provider addresses performed in _updateProviderSalesAddresses
-        // initialize default sales revenue percentages and basis points
-        _renderProviderPrimarySalesPercentage = 10;
-        defaultRenderProviderSecondarySalesBPS = 250;
-        _platformProviderPrimarySalesPercentage = engineConfiguration
-            .nullPlatformProvider
-            ? 0
-            : 10;
-        defaultPlatformProviderSecondarySalesBPS = engineConfiguration
-            .nullPlatformProvider
-            ? 0
-            : 250;
-
-        // set token name and token symbol
-        ERC721_PackedHashSeedV1.initialize(
-            engineConfiguration.tokenName,
-            engineConfiguration.tokenSymbol
-        );
-        // update minter if populated
-        if (engineConfiguration.minterFilterAddress != address(0)) {
-            _updateMinterContract(engineConfiguration.minterFilterAddress);
-        }
-        _updateSplitProvider(engineConfiguration.splitProviderAddress);
-        // setup immutable `autoApproveArtistSplitProposals` config
-        autoApproveArtistSplitProposals = engineConfiguration
-            .autoApproveArtistSplitProposals;
-        // setup immutable `nullPlatformProvider` config
-        nullPlatformProvider = engineConfiguration.nullPlatformProvider;
-        // setup immutable `allowArtistProjectActivation` config
-        allowArtistProjectActivation = engineConfiguration
-            .allowArtistProjectActivation;
-        // record contracts starting project ID
-        // casting-up is safe
-        startingProjectId = uint256(engineConfiguration.startingProjectId);
-        // @dev nullPlatformProvider must be set before calling _updateProviderSalesAddresses
-        _updateProviderSalesAddresses(
-            engineConfiguration.renderProviderAddress,
-            engineConfiguration.renderProviderAddress,
-            engineConfiguration.platformProviderAddress,
-            engineConfiguration.platformProviderAddress
-        );
-        _updateRandomizerAddress(engineConfiguration.randomizerContract);
-        // set AdminACL management contract as owner
-        _transferOwnership(adminACLContract_);
-        // initialize default base URI
-        _updateDefaultBaseURI(
-            string.concat(defaultBaseURIHost, address(this).toHexString(), "/")
-        );
-        // initialize next project ID
-        _nextProjectId = engineConfiguration.startingProjectId;
-        emit PlatformUpdated(
-            bytes32(uint256(PlatformUpdatedFields.FIELD_NEXT_PROJECT_ID))
-        );
-        // @dev This contract is registered on the core registry in a
-        // subsequent call by the factory.
+        string memory defaultBaseURIHost,
+        address bytecodeStorageReaderContract_
+    ) external virtual {
+        // @dev internal function call so derived contracts have access to initialization logic
+        _initialize({
+            engineConfiguration: engineConfiguration,
+            adminACLContract_: adminACLContract_,
+            defaultBaseURIHost: defaultBaseURIHost,
+            bytecodeStorageReaderContract_: bytecodeStorageReaderContract_
+        });
     }
 
     /**
@@ -1034,6 +987,22 @@ contract GenArt721CoreV3_Engine_Flex is
         _updateSplitProvider(_splitProviderAddress);
     }
 
+    /**
+     * @notice Updates bytecode storage reader contract to `_bytecodeStorageReaderContract`.
+     * Reverts if `_bytecodeStorageReaderContract` is zero address.
+     * Updating the active Bytecode Storage Reader contract may affect the ability to read
+     * data related to existing projects. Care should be taken to ensure that the new
+     * contract is compatible with the existing project data.
+     * @param _bytecodeStorageReaderContract New bytecode storage reader contract address.
+     */
+    function updateBytecodeStorageReaderContract(
+        address _bytecodeStorageReaderContract
+    ) external {
+        _onlyAdminACL(this.updateBytecodeStorageReaderContract.selector);
+        _onlyNonZeroAddress(_bytecodeStorageReaderContract);
+        _updateBytecodeStorageReaderContract(_bytecodeStorageReaderContract);
+    }
+
     /**
      * @notice Toggles project `_projectId` as active/inactive.
      * @param _projectId Project ID to be toggled.
@@ -2122,6 +2091,7 @@ contract GenArt721CoreV3_Engine_Flex is
         string memory _script
     ) external pure returns (bytes memory) {
         _onlyNonEmptyString(_script);
+        // @dev want a potentially version-specific compression algorithm, so use version-specific library here
         return BytecodeStorageReader.getCompressed(_script);
     }
 
@@ -2336,7 +2306,8 @@ contract GenArt721CoreV3_Engine_Flex is
         return
             V3FlexLib.projectExternalAssetDependencyByIndex({
                 _projectId: _projectId,
-                _index: _index
+                _index: _index,
+                _bytecodeStorageReaderContract: bytecodeStorageReaderContract
             });
     }
 
@@ -2593,6 +2564,23 @@ contract GenArt721CoreV3_Engine_Flex is
         );
     }
 
+    /**
+     * @notice Update the bytecode storage reader contract address, and emit corresponding event.
+     * @param _bytecodeStorageReaderContract New bytecode storage reader contract address.
+     */
+    function _updateBytecodeStorageReaderContract(
+        address _bytecodeStorageReaderContract
+    ) internal {
+        bytecodeStorageReaderContract = IBytecodeStorageReader_Base(
+            _bytecodeStorageReaderContract
+        );
+        emit PlatformUpdated(
+            bytes32(
+                uint256(PlatformUpdatedFields.FIELD_BYTECODE_STORAGE_READER)
+            )
+        );
+    }
+
     /**
      * @notice internal function to update a splitter contract for a project,
      * based on the project's financials in this contract's storage.
@@ -2663,6 +2651,88 @@ contract GenArt721CoreV3_Engine_Flex is
         );
     }
 
+    /**
+     * @notice Initializes the contract with the provided `engineConfiguration`.
+     * This function should be called atomically, immediately after deployment.
+     * Only callable once. Validation on `engineConfiguration` is performed by caller.
+     * @param engineConfiguration EngineConfiguration to configure the contract with.
+     * note: parameter `engineConfiguration.newSuperAdminAddress` is not used or operated on in this contract.
+     * @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 bytecode storage reader contract.
+     */
+    function _initialize(
+        EngineConfiguration memory engineConfiguration,
+        address adminACLContract_,
+        string memory defaultBaseURIHost,
+        address bytecodeStorageReaderContract_
+    ) internal {
+        // can only be initialized once
+        if (_initialized) {
+            revert GenArt721Error(ErrorCodes.ContractInitialized);
+        }
+        // immediately mark as initialized
+        _initialized = true;
+        // @dev assume renderProviderAddress, randomizer, and AdminACL non-zero
+        // checks on platform provider addresses performed in _updateProviderSalesAddresses
+        // initialize default sales revenue percentages and basis points
+        _renderProviderPrimarySalesPercentage = 10;
+        defaultRenderProviderSecondarySalesBPS = 250;
+        _platformProviderPrimarySalesPercentage = engineConfiguration
+            .nullPlatformProvider
+            ? 0
+            : 10;
+        defaultPlatformProviderSecondarySalesBPS = engineConfiguration
+            .nullPlatformProvider
+            ? 0
+            : 250;
+
+        // set token name and token symbol
+        ERC721_PackedHashSeedV1.initialize(
+            engineConfiguration.tokenName,
+            engineConfiguration.tokenSymbol
+        );
+        // update minter if populated
+        if (engineConfiguration.minterFilterAddress != address(0)) {
+            _updateMinterContract(engineConfiguration.minterFilterAddress);
+        }
+        _updateSplitProvider(engineConfiguration.splitProviderAddress);
+        _updateBytecodeStorageReaderContract(bytecodeStorageReaderContract_);
+        // setup immutable `autoApproveArtistSplitProposals` config
+        autoApproveArtistSplitProposals = engineConfiguration
+            .autoApproveArtistSplitProposals;
+        // setup immutable `nullPlatformProvider` config
+        nullPlatformProvider = engineConfiguration.nullPlatformProvider;
+        // setup immutable `allowArtistProjectActivation` config
+        allowArtistProjectActivation = engineConfiguration
+            .allowArtistProjectActivation;
+        // record contracts starting project ID
+        // casting-up is safe
+        startingProjectId = uint256(engineConfiguration.startingProjectId);
+        // @dev nullPlatformProvider must be set before calling _updateProviderSalesAddresses
+        _updateProviderSalesAddresses(
+            engineConfiguration.renderProviderAddress,
+            engineConfiguration.renderProviderAddress,
+            engineConfiguration.platformProviderAddress,
+            engineConfiguration.platformProviderAddress
+        );
+        _updateRandomizerAddress(engineConfiguration.randomizerContract);
+        // set AdminACL management contract as owner
+        _transferOwnership(adminACLContract_);
+        // initialize default base URI
+        _updateDefaultBaseURI(
+            string.concat(defaultBaseURIHost, address(this).toHexString(), "/")
+        );
+        // initialize next project ID
+        _nextProjectId = engineConfiguration.startingProjectId;
+        emit PlatformUpdated(
+            bytes32(uint256(PlatformUpdatedFields.FIELD_NEXT_PROJECT_ID))
+        );
+        // @dev This contract is registered on the core registry in a
+        // subsequent call by the factory.
+    }
+
     /**
      * @notice Internal function that returns whether a project is unlocked.
      * Projects automatically lock four weeks after they are completed.
@@ -2685,12 +2755,12 @@ contract GenArt721CoreV3_Engine_Flex is
     }
 
     /**
-     * Helper for calling `BytecodeStorageReader` external library reader method,
+     * @notice Helper for calling bytecodeStorageReaderContract reader method;
      * added for bytecode size reduction purposes.
      */
     function _readFromBytecode(
         address _address
     ) internal view returns (string memory) {
-        return BytecodeStorageReader.readFromBytecode(_address);
+        return bytecodeStorageReaderContract.readFromBytecode(_address);
     }
 }

package/contracts/generator/AddressChunks.sol

@@ -0,0 +1,106 @@
+// Forked from https://github.com/intartnft/scripty.sol/blob/28cc612d7dc3a709f35c534c981bfc6bbfce4209/contracts/scripty/utils/AddressChunks.sol
+// with adjustment to data offset for compatibility with Art Blocks BytecodeStorage.sol
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+library AddressChunks {
+    /**
+     * @notice Merge multiple chunks of contract code into a single bytes array.
+     * Offloads details of reading contract code to UniversalBytecodeStorageReader contract, but efficiently
+     * merges staticcall responses into a single bytes array using assembly.
+     * @dev This could become more gas efficient by implementing logic in the bytecode storage reader contracts
+     * here instead of moving large amounts of data through return data, but this implementation is much simpler
+     * and maintainable.
+     * @param chunks Array of contract addresses to merge
+     * @param universalReaderContract Address of the UniversalBytecodeStorageReader contract to use for reading
+     * stored bytecode (Art Blocks BytecodeStorage library)
+     * @return o_code Merged contract code
+     */
+    function mergeChunks(
+        address[] memory chunks,
+        address universalReaderContract
+    ) internal view returns (bytes memory o_code) {
+        unchecked {
+            assembly ("memory-safe") {
+                // part 1: provision memory for calldata to universal reader's readFromBytecode function
+                // 4 bytes for function selector, 32 bytes for address
+                let readerCalldata := mload(0x40)
+                mstore(readerCalldata, 0x75662f38) // function selector for readFromBytecode(address)
+                // calldata in memory will look like:
+                //  0000000000000000000000000000000000000000000000000000000075662f38
+                //  000000000000000000000000<-------------chunk-address------------>
+                // @dev do not populate address yet - do in call loop
+                // update free memory pointer two words ahead, past end reserved for calldata
+                mstore(0x40, add(readerCalldata, 0x40))
+                // update calldata to point to the start of the function selector
+                readerCalldata := add(readerCalldata, 28)
+
+                // part 2: reserve space 0x20 bytes representing the returned string length data for each call in loop
+                let returnDataStringLength := mload(0x40)
+                // update free memory pointer one word ahead, past end of returnDataStringLength
+                mstore(0x40, add(returnDataStringLength, 0x20))
+
+                // part 3: build o_code while looping through chunks
+                let len := mload(chunks)
+                let totalSize := 0x20
+                o_code := mload(0x40)
+
+                // loop through all chunk addresses
+                // - get address
+                // - get data size
+                // - get code and add to o_code
+                // - update total size
+                let targetChunk := 0
+                for {
+                    let i := 0
+                } lt(i, len) {
+                    i := add(i, 1)
+                } {
+                    targetChunk := mload(add(chunks, add(0x20, mul(i, 0x20))))
+                    // update calldata with targetChunk address
+                    mstore(add(readerCalldata, 0x04), targetChunk) // offset by 4-byte function selector
+                    // call the readFromBytecode(address) function of contract targetChunk and don't store the result
+                    if iszero(
+                        staticcall(
+                            gas(), // forward all gas
+                            universalReaderContract, // target address with the data stored as bytecode
+                            readerCalldata, // start of calldata
+                            0x24, // calldata size is 0x04 (function selector) + 0x20 (abi-encoded address)
+                            0x00, // 0x00 (do not store return data)
+                            0x00 // 0x00 (do not store return data)
+                        )
+                    ) {
+                        revert(0, 0) // call failed, revert
+                    }
+
+                    // store return data string length
+                    returndatacopy(
+                        returnDataStringLength,
+                        0x20, // start of return data's string length (ABI spec)
+                        0x20 // size of length data (ABI spec)
+                    )
+
+                    // store the return string data in memory starting at o_code + totalSize
+                    // first 0x20 bytes of return data points to the location of the string data (ABI spec)
+                    // second 0x20 bytes of return data is the length of the data (ABI spec)
+                    // the actual string data contents begin at returndata + 0x40
+                    let storedReturnSize := mload(returnDataStringLength)
+                    returndatacopy(
+                        add(o_code, totalSize), // offset by totalSize
+                        0x40, // skip the 0x40 bytes of length data at the start of the expected return data
+                        storedReturnSize // return data size, as gathered above
+                    )
+                    totalSize := add(totalSize, storedReturnSize) // update total size
+                }
+
+                // update o_code length in memory
+                mstore(o_code, sub(totalSize, 0x20))
+                // new "memory end" including padding
+                mstore(
+                    0x40,
+                    add(o_code, and(add(add(totalSize, 0x20), 0x1f), not(0x1f)))
+                )
+            }
+        }
+    }
+}