@artblocks/contracts 1.2.0 → 1.3.0

package/contracts/OwnedCreate2FactoryV0.sol

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+// @dev fixed to specific solidity version for clarity and for more clear
+// source code verification purposes.
+pragma solidity 0.8.22;
+
+import {IOwnedCreate2FactoryV0} from "./interfaces/v0.8.x/IOwnedCreate2FactoryV0.sol";
+
+import "@openzeppelin-5.0/contracts/access/Ownable.sol";
+import {IERC20} from "@openzeppelin-5.0/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin-5.0/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Create2} from "@openzeppelin-5.0/contracts/utils/Create2.sol";
+
+/**
+ * @title OwnedCreate2FactoryV0
+ * @author Art Blocks Inc.
+ * @notice Owned, Create2 factory contract for deploying arbitrary contracts from a single wallet.
+ * This contract is intended to be used as a factory for deploying other contracts, while also allowing
+ * the owner to drain the contract's balance to a recipient address. The contract also provides a
+ * function to execute a batch of calls, which can be useful for interacting with contracts that
+ * might deem this contract eligible for airdrops, thereby avoiding loss of funds.
+ */
+contract OwnedCreate2FactoryV0 is Ownable, IOwnedCreate2FactoryV0 {
+    // public type
+    bytes32 public constant type_ = "OwnedCreate2FactoryV0";
+
+    /**
+     * Represents a generic call operation.
+     */
+    struct Call {
+        address to;
+        bytes data;
+    }
+
+    /**
+     * @notice creates this contract and deploys the curated contract
+     * @param owner_ address of the initial owner of this contract to execute all future calls
+     */
+    constructor(address owner_) Ownable(owner_) {
+        // input validation
+        // @dev Ownable enforces that the owner must be non-zero
+
+        // emit Deployed event
+        emit Deployed();
+    }
+
+    /**
+     * @notice Deploy a new contract using create2.
+     * Reverts if the initcode is empty.
+     * Reverts if not called by the owner.
+     * The address of the new contract is deterministic based on the salt and initcode, and may be obtained by calling
+     * the `predictDeterministicAddress` function.
+     * @param salt The salt to use for the deployment.
+     * @param initcode The initcode of the contract to deploy.
+     * @return newContract The address of the newly deployed contract.
+     */
+    function deployCreate2(
+        bytes32 salt,
+        bytes calldata initcode
+    ) external payable onlyOwner returns (address newContract) {
+        // input validation
+        // @dev Create2.deploy will revert if initcode is empty
+
+        // deploy contract
+        newContract = Create2.deploy({
+            amount: msg.value,
+            salt: salt,
+            bytecode: initcode
+        });
+
+        emit ContractCreated({newContract: newContract});
+        return newContract;
+    }
+
+    /**
+     * @dev This contract is not intended to hold funds. This function,
+     * `drainETH`, and `drainERC20` are implemented to prevent the loss
+     * of funds that might be sent to this contract inadvertently.
+     */
+    receive() external payable {}
+
+    /**
+     * @notice Drains the contract's balance to the `recipient`.
+     * @param recipient The address to send funds to.
+     * Only callable by the owner.
+     */
+    function drainETH(address payable recipient) external onlyOwner {
+        uint256 balance = address(this).balance;
+        if (balance > 0) {
+            (bool success, ) = recipient.call{value: balance}("");
+            require(success, "Payment failed");
+        }
+    }
+
+    /**
+     * @notice Drains the contract's balance of an input ERC20 token to
+     * the `recipient`.
+     * @param ERC20TokenAddress The address of the ERC20 token to withdraw.
+     * @param recipient The address to send ERC20 tokens to.
+     * Only callable by the owner.
+     */
+    function drainERC20(
+        address ERC20TokenAddress,
+        address recipient
+    ) external onlyOwner {
+        IERC20 token = IERC20(ERC20TokenAddress);
+        uint256 balance = token.balanceOf(address(this));
+        if (balance > 0) {
+            SafeERC20.safeTransfer({
+                token: token,
+                to: recipient,
+                value: balance
+            });
+        }
+    }
+
+    /**
+     * @notice Execute a batch of calls.
+     * @dev The calls are executed in order, reverting if any of them fails. Can
+     * only be called by the owner. It is safe to check ownership only once here
+     * because the owner status is only used to gate access to the function, not
+     * to validate each individual call. Even if ownership is transferred during
+     * the sequence of calls, it does not affect the execution logic or security,
+     * as ownership is solely used to prevent unauthorized use of this batch
+     * execution capability. This is particularly useful to safely interact
+     * with contracts or addresses that might deem this contract eligible for
+     * airdrops, thereby avoiding loss of funds.
+     * @param _calls The calls to execute
+     */
+    function execCalls(
+        Call[] calldata _calls
+    )
+        external
+        onlyOwner
+        returns (uint256 blockNumber, bytes[] memory returnData)
+    {
+        blockNumber = block.number;
+        uint256 length = _calls.length;
+        returnData = new bytes[](length);
+
+        for (uint256 i = 0; i < length; ++i) {
+            Call calldata calli = _calls[i];
+
+            // check for existence of code at the target address
+            if (calli.to.code.length == 0) {
+                // when the call is to an EOA, the calldata must be empty.
+                require(calli.data.length == 0, "Invalid call data");
+            }
+
+            (bool success, bytes memory data) = calli.to.call(calli.data);
+            require(success, string(data));
+            returnData[i] = data;
+        }
+    }
+
+    /**
+     * @dev Predict the deterministic address for a new deployment using create2.
+     * @param salt Salt used to deterministically deploy the clone.
+     * @param initcode The initcode of the contract to deploy.
+     */
+
+    function predictDeterministicAddress(
+        bytes32 salt,
+        bytes memory initcode
+    ) external view returns (address predicted) {
+        return
+            Create2.computeAddress({
+                salt: salt,
+                bytecodeHash: keccak256(initcode)
+            });
+    }
+}

package/contracts/engine/V3/EngineFactoryV0.sol

@@ -65,6 +65,9 @@ contract EngineFactoryV0 is Ownable, IEngineFactoryV0 {
      */
     bool public isAbandoned; // default false
 
+    /// Universal Bytecode Storage Reader contract address, which all core contracts are initialized to use
+    address public immutable universalBytecodeStorageReader;
+
     // pseudorandom salt nonce to prevent collisions for multiple contract deployments in single block
     uint256 private _pseudorandomSaltNonce;
 
@@ -87,13 +90,15 @@ contract EngineFactoryV0 is Ownable, IEngineFactoryV0 {
      * @param owner_ address of the initial owner
      * @param defaultBaseURIHost_ default base URI prefix for all Engine contracts,
      * e.g. "https://token.artblocks.io/" for mainnet, "https://token.arbitrum.artblocks.io/" for arbitrum, etc.
+     * @param universalBytecodeStorageReader_ address of the UniversalBytecodeStorageReader contract
      */
     constructor(
         address engineImplementation_,
         address engineFlexImplementation_,
         address coreRegistry_,
         address owner_,
-        string memory defaultBaseURIHost_
+        string memory defaultBaseURIHost_,
+        address universalBytecodeStorageReader_
     ) Ownable(owner_) {
         _onlyNonZeroAddress(engineImplementation_);
         _onlyNonZeroAddress(engineFlexImplementation_);
@@ -117,6 +122,8 @@ contract EngineFactoryV0 is Ownable, IEngineFactoryV0 {
             engineFlexImplementation
         ).coreVersion();
 
+        universalBytecodeStorageReader = universalBytecodeStorageReader_;
+
         // emit event
         emit Deployed({
             engineImplementation: engineImplementation_,
@@ -191,7 +198,8 @@ contract EngineFactoryV0 is Ownable, IEngineFactoryV0 {
         IGenArt721CoreContractV3_Engine(engineContract).initialize({
             engineConfiguration: engineConfiguration,
             adminACLContract_: adminACLContract,
-            defaultBaseURIHost: defaultBaseURIHost
+            defaultBaseURIHost: defaultBaseURIHost,
+            bytecodeStorageReaderContract_: universalBytecodeStorageReader
         });
 
         (

package/contracts/engine/V3/GenArt721CoreV3_Engine.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 "../../libs/v0.8.x/Bytes32Strings.sol";
 
 /**
@@ -48,6 +49,7 @@ import "../../libs/v0.8.x/Bytes32Strings.sol";
  * - forbidNewProjects (forever forbidding new projects)
  * - updateDefaultBaseURI (used to initialize new project base URIs)
  * - updateSplitProvider
+ * - updateBytecodeStorageReaderContract
  * ----------------------------------------------------------------------------
  * The following functions are restricted to either the Artist address or
  * the Admin ACL contract, only when the project is not locked:
@@ -265,9 +267,9 @@ contract GenArt721CoreV3_Engine is
     bool public allowArtistProjectActivation;
 
     /// version & type of this core contract
-    bytes32 constant CORE_VERSION = "v3.2.2";
+    bytes32 constant CORE_VERSION = "v3.2.4";
 
-    function coreVersion() external pure returns (string memory) {
+    function coreVersion() external pure virtual returns (string memory) {
         return CORE_VERSION.toString();
     }
 
@@ -287,6 +289,9 @@ contract GenArt721CoreV3_Engine 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
@@ -395,77 +400,25 @@ contract GenArt721CoreV3_Engine 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_
+        });
     }
 
     /**
@@ -814,6 +767,22 @@ contract GenArt721CoreV3_Engine 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.
@@ -1902,6 +1871,7 @@ contract GenArt721CoreV3_Engine 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);
     }
 
@@ -2320,6 +2290,23 @@ contract GenArt721CoreV3_Engine 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.
@@ -2390,6 +2377,88 @@ contract GenArt721CoreV3_Engine 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.
@@ -2412,12 +2481,12 @@ contract GenArt721CoreV3_Engine 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);
     }
 }