@artblocks/contracts 1.0.2 → 1.0.4

package/contracts/minter-suite/Minters/MinterSetPriceV4.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 // Created By: Art Blocks Inc.
 
-import "../../interfaces/0.8.x/IGenArt721CoreContractV3_Base.sol";
-import "../../interfaces/0.8.x/IMinterFilterV0.sol";
-import "../../interfaces/0.8.x/IFilteredMinterV2.sol";
+import "../../interfaces/v0.8.x/IGenArt721CoreContractV3_Base.sol";
+import "../../interfaces/v0.8.x/IMinterFilterV0.sol";
+import "../../interfaces/v0.8.x/IFilteredMinterV2.sol";
 import "./MinterBase_v0_1_1.sol";
 
 import "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 /**
  * @title Filtered Minter contract that allows tokens to be minted with ETH.

package/contracts/minter-suite/Minters/MinterSetPriceV5.sol

@@ -0,0 +1,461 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../../interfaces/v0.8.x/ISharedMinterSimplePurchaseV0.sol";
+import "../../interfaces/v0.8.x/ISharedMinterV0.sol";
+import "../../interfaces/v0.8.x/IMinterFilterV1.sol";
+
+import "../../libs/v0.8.x/AuthLib.sol";
+import "../../libs/v0.8.x/minter-libs/SplitFundsLib.sol";
+import "../../libs/v0.8.x/minter-libs/MaxInvocationsLib.sol";
+import "../../libs/v0.8.x/minter-libs/SetPriceLib.sol";
+
+import "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
+
+pragma solidity 0.8.19;
+
+/**
+ * @title Shared, filtered Minter contract that allows tokens to be minted with
+ * ETH.
+ * This is designed to be used with GenArt721CoreContractV3 flagship or
+ * engine contracts.
+ * @author Art Blocks Inc.
+ * @notice Privileged Roles and Ownership:
+ * This contract is designed to be managed, with limited powers.
+ * Privileged roles and abilities are controlled by the project's artist, which
+ * can be modified by the core contract's Admin ACL contract. Both of these
+ * roles hold extensive power and can modify minter details.
+ * Care must be taken to ensure that the admin ACL contract and artist
+ * addresses are secure behind a multi-sig or other access control mechanism.
+ * ----------------------------------------------------------------------------
+ * The following functions are restricted to a project's artist:
+ * - updatePricePerTokenInWei
+ * - syncProjectMaxInvocationsToCore
+ * - manuallyLimitProjectMaxInvocations
+ * ----------------------------------------------------------------------------
+ * Additional admin and artist privileged roles may be described on other
+ * contracts that this minter integrates with.
+ */
+contract MinterSetPriceV5 is
+    ReentrancyGuard,
+    ISharedMinterSimplePurchaseV0,
+    ISharedMinterV0
+{
+    /// Minter filter address this minter interacts with
+    address public immutable minterFilterAddress;
+
+    /// Minter filter this minter may interact with.
+    IMinterFilterV1 private immutable minterFilter;
+
+    /// minterType for this minter
+    string public constant minterType = "MinterSetPriceV5";
+
+    /// minter version for this minter
+    string public constant minterVersion = "v5.0.0";
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // STATE VARIABLES FOR SetPriceLib begin here
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /// contractAddress => projectId => set price project config
+    mapping(address => mapping(uint256 => SetPriceLib.SetPriceProjectConfig))
+        private _setPriceProjectConfigMapping;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // STATE VARIABLES FOR SetPriceLib end here
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // STATE VARIABLES FOR SplitFundsLib begin here
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    // contractAddress => IsEngineCache
+    mapping(address => SplitFundsLib.IsEngineCache) private _isEngineCaches;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // STATE VARIABLES FOR SplitFundsLib end here
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // STATE VARIABLES FOR MaxInvocationsLib begin here
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    // contractAddress => projectId => max invocations specific project config
+    mapping(address => mapping(uint256 => MaxInvocationsLib.MaxInvocationsProjectConfig))
+        private _maxInvocationsProjectConfigMapping;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // STATE VARIABLES FOR MaxInvocationsLib end here
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    // MODIFIERS
+    // @dev contract uses modifier-like internal functions instead of modifiers
+    // to reduce contract bytecode size
+    // @dev contract uses AuthLib for some modifier-like functions
+
+    /**
+     * @notice Initializes contract to be a Filtered Minter for
+     * `_minterFilter` minter filter.
+     * @param _minterFilter Minter filter for which this will be a
+     * filtered minter.
+     */
+    constructor(address _minterFilter) ReentrancyGuard() {
+        minterFilterAddress = _minterFilter;
+        minterFilter = IMinterFilterV1(_minterFilter);
+    }
+
+    /**
+     * @notice Manually sets the local maximum invocations of project `_projectId`
+     * with the provided `_maxInvocations`, checking that `_maxInvocations` is less
+     * than or equal to the value of project `_project_id`'s maximum invocations that is
+     * set on the core contract.
+     * @dev Note that a `_maxInvocations` of 0 can only be set if the current `invocations`
+     * value is also 0 and this would also set `maxHasBeenInvoked` to true, correctly short-circuiting
+     * this minter's purchase function, avoiding extra gas costs from the core contract's maxInvocations check.
+     * @param _projectId Project ID to set the maximum invocations for.
+     * @param _coreContract Core contract address for the given project.
+     * @param _maxInvocations Maximum invocations to set for the project.
+     */
+    function manuallyLimitProjectMaxInvocations(
+        uint256 _projectId,
+        address _coreContract,
+        uint24 _maxInvocations
+    ) external {
+        AuthLib.onlyArtist({
+            _projectId: _projectId,
+            _coreContract: _coreContract,
+            _sender: msg.sender
+        });
+        MaxInvocationsLib.manuallyLimitProjectMaxInvocations(
+            _projectId,
+            _coreContract,
+            _maxInvocations,
+            _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
+        );
+        emit ProjectMaxInvocationsLimitUpdated(
+            _projectId,
+            _coreContract,
+            _maxInvocations
+        );
+    }
+
+    /**
+     * @notice Updates this minter's price per token of project `_projectId`
+     * to be '_pricePerTokenInWei`, in Wei.
+     * @dev Note that it is intentionally supported here that the configured
+     * price may be explicitly set to `0`.
+     * @param _projectId Project ID to set the price per token for.
+     * @param _coreContract Core contract address for the given project.
+     * @param _pricePerTokenInWei Price per token to set for the project, in Wei.
+     */
+    function updatePricePerTokenInWei(
+        uint256 _projectId,
+        address _coreContract,
+        uint248 _pricePerTokenInWei
+    ) external {
+        AuthLib.onlyArtist({
+            _projectId: _projectId,
+            _coreContract: _coreContract,
+            _sender: msg.sender
+        });
+        SetPriceLib.SetPriceProjectConfig
+            storage _setPriceProjectConfig = _setPriceProjectConfigMapping[
+                _coreContract
+            ][_projectId];
+        SetPriceLib.updatePricePerTokenInWei(
+            _pricePerTokenInWei,
+            _setPriceProjectConfig
+        );
+        emit PricePerTokenInWeiUpdated(
+            _projectId,
+            _coreContract,
+            _pricePerTokenInWei
+        );
+
+        // for convenience, sync local max invocations to the core contract if
+        // and only if max invocations have not already been synced.
+        // @dev do not sync if max invocations have already been synced, as
+        // local max invocations could have been manually set to be
+        // intentionally less than the core contract's max invocations.
+        MaxInvocationsLib.MaxInvocationsProjectConfig
+            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
+                _coreContract
+            ][_projectId];
+        // @dev if local maxInvocations and maxHasBeenInvoked are both
+        // initial values, we know they have not been populated on this minter
+        if (
+            MaxInvocationsLib.maxInvocationsIsUnconfigured(
+                _maxInvocationsProjectConfig
+            )
+        ) {
+            syncProjectMaxInvocationsToCore(_projectId, _coreContract);
+        }
+    }
+
+    /**
+     * @notice Purchases a token from project `_projectId`.
+     * @param _projectId Project ID to mint a token on.
+     * @param _coreContract Core contract address for the given project.
+     * @return tokenId Token ID of minted token
+     */
+    function purchase(
+        uint256 _projectId,
+        address _coreContract
+    ) external payable returns (uint256 tokenId) {
+        tokenId = purchaseTo(msg.sender, _projectId, _coreContract);
+        return tokenId;
+    }
+
+    // public getter functions
+    /**
+     * @notice Gets the maximum invocations project configuration.
+     * @param _projectId The ID of the project whose data needs to be fetched.
+     * @param _coreContract The address of the core contract.
+     * @return MaxInvocationsLib.MaxInvocationsProjectConfig instance with the
+     * configuration data.
+     */
+    function maxInvocationsProjectConfig(
+        uint256 _projectId,
+        address _coreContract
+    )
+        external
+        view
+        returns (MaxInvocationsLib.MaxInvocationsProjectConfig memory)
+    {
+        return _maxInvocationsProjectConfigMapping[_coreContract][_projectId];
+    }
+
+    /**
+     * @notice Gets the set price project configuration.
+     * @param _projectId The ID of the project whose data needs to be fetched.
+     * @param _coreContract The address of the core contract.
+     * @return SetPriceProjectConfig struct with the fixed price project
+     * configuration data.
+     */
+    function setPriceProjectConfig(
+        uint256 _projectId,
+        address _coreContract
+    ) external view returns (SetPriceLib.SetPriceProjectConfig memory) {
+        return _setPriceProjectConfigMapping[_coreContract][_projectId];
+    }
+
+    /**
+     * @notice Checks if the specified `_coreContract` is a valid engine contract.
+     * @dev This function retrieves the cached value of `_isEngine` from
+     * the `isEngineCache` mapping. If the cached value is already set, it
+     * returns the cached value. Otherwise, it calls the `getV3CoreIsEngine`
+     * function from the `SplitFundsLib` library to check if `_coreContract`
+     * is a valid engine contract.
+     * @dev This function will revert if the provided `_coreContract` is not
+     * a valid Engine or V3 Flagship contract.
+     * @param _coreContract The address of the contract to check.
+     * @return bool indicating if `_coreContract` is a valid engine contract.
+     */
+    function isEngineView(address _coreContract) external view returns (bool) {
+        SplitFundsLib.IsEngineCache storage isEngineCache = _isEngineCaches[
+            _coreContract
+        ];
+        if (isEngineCache.isCached) {
+            return isEngineCache.isEngine;
+        } else {
+            // @dev this calls the non-modifying variant of getV3CoreIsEngine
+            return SplitFundsLib.getV3CoreIsEngineView(_coreContract);
+        }
+    }
+
+    /**
+     * @notice projectId => has project reached its maximum number of
+     * invocations? Note that this returns a local cache of the core contract's
+     * state, and may be out of sync with the core contract. This is
+     * intentional, as it only enables gas optimization of mints after a
+     * project's maximum invocations has been reached. A false negative will
+     * only result in a gas cost increase, since the core contract will still
+     * enforce a maxInvocation check during minting. A false positive is not
+     * possible because the V3 core contract only allows maximum invocations
+     * to be reduced, not increased. Based on this rationale, we intentionally
+     * do not do input validation in this method as to whether or not the input
+     * @param `_projectId` is an existing project ID.
+     * @param `_coreContract` is an existing core contract address.
+     */
+    function projectMaxHasBeenInvoked(
+        uint256 _projectId,
+        address _coreContract
+    ) external view returns (bool) {
+        return
+            MaxInvocationsLib.getMaxHasBeenInvoked(
+                _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
+            );
+    }
+
+    /**
+     * @notice projectId => project's maximum number of invocations.
+     * Optionally synced with core contract value, for gas optimization.
+     * Note that this returns a local cache of the core contract's
+     * state, and may be out of sync with the core contract. This is
+     * intentional, as it only enables gas optimization of mints after a
+     * project's maximum invocations has been reached.
+     * @dev A number greater than the core contract's project max invocations
+     * will only result in a gas cost increase, since the core contract will
+     * still enforce a maxInvocation check during minting. A number less than
+     * the core contract's project max invocations is only possible when the
+     * project's max invocations have not been synced on this minter, since the
+     * V3 core contract only allows maximum invocations to be reduced, not
+     * increased. When this happens, the minter will enable minting, allowing
+     * the core contract to enforce the max invocations check. Based on this
+     * rationale, we intentionally do not do input validation in this method as
+     * to whether or not the input `_projectId` is an existing project ID.
+     * @param `_projectId` is an existing project ID.
+     * @param `_coreContract` is an existing core contract address.
+     */
+    function projectMaxInvocations(
+        uint256 _projectId,
+        address _coreContract
+    ) external view returns (uint256) {
+        return
+            MaxInvocationsLib.getMaxInvocations(
+                _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
+            );
+    }
+
+    /**
+     * @notice Gets if price of token is configured, price of minting a
+     * token on project `_projectId`, and currency symbol and address to be
+     * used as payment.
+     * @param _projectId Project ID to get price information for
+     * @param _coreContract Contract address of the core contract
+     * @return isConfigured true only if token price has been configured on
+     * this minter
+     * @return tokenPriceInWei current price of token on this minter - invalid
+     * if price has not yet been configured
+     * @return currencySymbol currency symbol for purchases of project on this
+     * minter. This minter always returns "ETH"
+     * @return currencyAddress currency address for purchases of project on
+     * this minter. This minter always returns null address, reserved for ether
+     */
+    function getPriceInfo(
+        uint256 _projectId,
+        address _coreContract
+    )
+        external
+        view
+        returns (
+            bool isConfigured,
+            uint256 tokenPriceInWei,
+            string memory currencySymbol,
+            address currencyAddress
+        )
+    {
+        SetPriceLib.SetPriceProjectConfig
+            storage _setPriceProjectConfig = _setPriceProjectConfigMapping[
+                _coreContract
+            ][_projectId];
+        isConfigured = _setPriceProjectConfig.priceIsConfigured;
+        tokenPriceInWei = _setPriceProjectConfig.pricePerTokenInWei;
+        currencySymbol = "ETH";
+        currencyAddress = address(0);
+    }
+
+    /**
+     * @notice Syncs local maximum invocations of project `_projectId` based on
+     * the value currently defined in the core contract.
+     * @param _projectId Project ID to set the maximum invocations for.
+     * @param _coreContract Core contract address for the given project.
+     * @dev this enables gas reduction after maxInvocations have been reached -
+     * core contracts shall still enforce a maxInvocation check during mint.
+     */
+    function syncProjectMaxInvocationsToCore(
+        uint256 _projectId,
+        address _coreContract
+    ) public {
+        AuthLib.onlyArtist({
+            _projectId: _projectId,
+            _coreContract: _coreContract,
+            _sender: msg.sender
+        });
+
+        uint256 maxInvocations = MaxInvocationsLib
+            .syncProjectMaxInvocationsToCore(
+                _projectId,
+                _coreContract,
+                _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
+            );
+        emit ProjectMaxInvocationsLimitUpdated(
+            _projectId,
+            _coreContract,
+            maxInvocations
+        );
+    }
+
+    /**
+     * @notice Purchases a token from project `_projectId` and sets
+     * the token's owner to `_to`.
+     * @param _to Address to be the new token's owner.
+     * @param _projectId Project ID to mint a token on.
+     * @param _coreContract Core contract address for the given project.
+     * @return tokenId Token ID of minted token
+     */
+    function purchaseTo(
+        address _to,
+        uint256 _projectId,
+        address _coreContract
+    ) public payable nonReentrant returns (uint256 tokenId) {
+        // CHECKS
+        SetPriceLib.SetPriceProjectConfig
+            storage _setPriceProjectConfig = _setPriceProjectConfigMapping[
+                _coreContract
+            ][_projectId];
+        MaxInvocationsLib.MaxInvocationsProjectConfig
+            storage _maxInvocationsProjectConfig = _maxInvocationsProjectConfigMapping[
+                _coreContract
+            ][_projectId];
+
+        // Note that `maxHasBeenInvoked` is only checked here to reduce gas
+        // consumption after a project has been fully minted.
+        // `_maxInvocationsProjectConfig.maxHasBeenInvoked` is locally cached to reduce
+        // gas consumption, but if not in sync with the core contract's value,
+        // the core contract also enforces its own max invocation check during
+        // minting.
+        require(
+            !_maxInvocationsProjectConfig.maxHasBeenInvoked,
+            "Max invocations reached"
+        );
+
+        // require artist to have configured price of token on this minter
+        require(
+            _setPriceProjectConfig.priceIsConfigured,
+            "Price not configured"
+        );
+
+        // load price of token into memory
+        uint256 pricePerTokenInWei = _setPriceProjectConfig.pricePerTokenInWei;
+
+        require(msg.value >= pricePerTokenInWei, "Min value to mint req.");
+
+        // EFFECTS
+        tokenId = minterFilter.mint_joo(
+            _to,
+            _projectId,
+            _coreContract,
+            msg.sender
+        );
+
+        MaxInvocationsLib.validatePurchaseEffectsInvocations(
+            tokenId,
+            _maxInvocationsProjectConfigMapping[_coreContract][_projectId]
+        );
+
+        // INTERACTIONS
+        bool isEngine = SplitFundsLib.isEngine(
+            _coreContract,
+            _isEngineCaches[_coreContract]
+        );
+        SplitFundsLib.splitFundsETH({
+            _projectId: _projectId,
+            _pricePerTokenInWei: pricePerTokenInWei,
+            _coreContract: _coreContract,
+            _isEngine: isEngine
+        });
+
+        return tokenId;
+    }
+}

package/contracts/mock/{BytecodeTextCR_DMock.sol → BytecodeV0TextCR_DMock.sol}

@@ -1,19 +1,19 @@
 // SPDX-License-Identifier: LGPL-3.0-only
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 // Created By: Art Blocks Inc.
 
-import "../libs/0.8.x/BytecodeStorage.sol";
+import "../libs/v0.8.x/BytecodeStorageV0.sol";
 
 /**
  * @title Art Blocks BytecodeTextCR_DMock.
  * @author Art Blocks Inc.
- * @notice This contract serves as a mock client of the BytecodeStorage library
+ * @notice This contract serves as a mock client of the BytecodeStorageV0 library
  *         to allow for more granular testing of this library than is supported
  *         by the usage of the library directly by specific current Art Blocks
  *         client smart contracts, such as the `GenArt721CoreV3` contract. This
  *         mock exposes the CR_D (create, read, _not updates_, delete)
- *         operations that the underlying BytecodeStorage library allows clients
+ *         operations that the underlying BytecodeStorageV0 library allows clients
  *         to support.
  *         Note that because updates can only functionally be performed by
  *         combining a "delete" and "create" operation, given that deployed
@@ -21,7 +21,7 @@ import "../libs/0.8.x/BytecodeStorage.sol";
  *         not expose updates (the usual "U" in "CRUD") as they are not
  *         supported by the underlying library.
  */
-contract BytecodeTextCR_DMock {
+contract BytecodeV0TextCR_DMock {
     using BytecodeStorage for string;
     using BytecodeStorage for address;
 

package/contracts/mock/BytecodeV1LibCallsMock.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.19;
+
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/IBytecodeStorageReader.sol";
+
+/**
+ * @title Art Blocks IBytecodeStorageReader-conforming mock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the BytecodeStorageV1 library
+ *         to allow for testing of making direct calls (rather than delegate calls)
+ *         to a deployed copy of the library. This is for testing purposes as this
+ *         is the expected integration flow for direct usage of the BytecodeStorageV1
+ *         reader library in a post-EOF world where new EOF-contracts cannot DELEGATECALL
+ *         into legacy contracts, in which we plan to have a BytecodeStorageV2 variant
+ *         of the library that makes use of CALL rather than DELEGATECALL for the
+ *         purposes of backwards-compatible reads.
+ */
+contract BytecodeV1LibCallsMock {
+    // Address of the deployed BytecodeStorageReader contract library under mock harness.
+    address public bytecodeStorageReaderDeploymentAddress;
+    // Deployed instance of the BytecodeStorageReader contract library under mock harness.
+    IBytecodeStorageReader private bytecodeStorageReaderDeployment;
+
+    /**
+     * @notice Initializes contract.
+     */
+    constructor(address _bytecodeStorageReaderDeploymentAddress) {
+        bytecodeStorageReaderDeploymentAddress = _bytecodeStorageReaderDeploymentAddress;
+        bytecodeStorageReaderDeployment = IBytecodeStorageReader(
+            _bytecodeStorageReaderDeploymentAddress
+        );
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                Proxy Read Operations of V1 Library
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Read a string from contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return data string read from contract bytecode
+     * @dev This function performs input validation that the contract to read is in an expected format
+     */
+    function readFromBytecode(
+        address _address
+    ) public view returns (string memory data) {
+        return bytecodeStorageReaderDeployment.readFromBytecode(_address);
+    }
+
+    /**
+     * @notice Read the bytes from contract bytecode that was written to the EVM using SSTORE2
+     * @param _address address of deployed contract with bytecode stored in the SSTORE2 format
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromSSTORE2Bytecode(
+        address _address
+    ) public view returns (bytes memory data) {
+        return
+            bytecodeStorageReaderDeployment.readBytesFromSSTORE2Bytecode(
+                _address
+            );
+    }
+
+    /**
+     * @notice Read the bytes from contract bytecode, with an explicitly provided starting offset
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @param _offset offset to read from in contract bytecode, explicitly provided (not calculated)
+     * @return data bytes read from contract bytecode
+     * @dev This function performs no input validation on the provided contract,
+     *      other than that there is content to read (but not that its a "storage contract")
+     */
+    function readBytesFromBytecode(
+        address _address,
+        uint256 _offset
+    ) public view returns (bytes memory data) {
+        return
+            bytecodeStorageReaderDeployment.readBytesFromBytecode(
+                _address,
+                _offset
+            );
+    }
+
+    /**
+     * @notice Get address for deployer for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return writerAddress address read from contract bytecode
+     */
+    function getWriterAddressForBytecode(
+        address _address
+    ) public view returns (address) {
+        return
+            bytecodeStorageReaderDeployment.getWriterAddressForBytecode(
+                _address
+            );
+    }
+
+    /**
+     * @notice Get version for given contract bytecode
+     * @param _address address of deployed contract with bytecode stored in the V0 or V1 format
+     * @return version version read from contract bytecode
+     */
+    function getLibraryVersionForBytecode(
+        address _address
+    ) public view returns (bytes32) {
+        return
+            bytecodeStorageReaderDeployment.getLibraryVersionForBytecode(
+                _address
+            );
+    }
+}