@artblocks/contracts 1.0.2 → 1.0.3

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

@@ -10,7 +10,7 @@ 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/MinterSetPriceV4.sol

@@ -8,7 +8,7 @@ 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/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/0.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/0.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
+            );
+    }
+}

package/contracts/mock/BytecodeV1TextCR_DMock.sol

@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.19;
+
+// Created By: Art Blocks Inc.
+
+import "../libs/0.8.x/BytecodeStorageV1.sol";
+
+/**
+ * @title Art Blocks BytecodeTextCR_DMock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the BytecodeStorageV1 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 BytecodeStorageV1 library allows clients
+ *         to support.
+ *         Note that because updates can only functionally be performed by
+ *         combining a "delete" and "create" operation, given that deployed
+ *         contracts cannot be _updated_ directly in chain-state, this mock does
+ *         not expose updates (the usual "U" in "CRUD") as they are not
+ *         supported by the underlying library.
+ */
+contract BytecodeV1TextCR_DMock {
+    using BytecodeStorageWriter for string;
+
+    // monotonically increasing slot counter and associated slot-storage mapping
+    uint256 public nextTextSlotId = 0;
+    mapping(uint256 => address) public storedTextBytecodeAddresses;
+
+    // save deployer address to support basic ACL checks for non-read operations
+    address public deployerAddress;
+
+    modifier onlyDeployer() {
+        require(msg.sender == deployerAddress, "Only deployer");
+        _;
+    }
+
+    /**
+     * @notice Initializes contract.
+     */
+    constructor() {
+        deployerAddress = msg.sender;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                     Create Read _ Delete
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice "Create": Adds a chunk of text to be stored to chain-state.
+     * @param _text Text to be created in chain-state.
+     * @return uint256 Slot that the written bytecode contract address was
+     *         stored in.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function createText(
+        string memory _text
+    ) external onlyDeployer returns (uint256) {
+        // store text in contract bytecode
+        storedTextBytecodeAddresses[nextTextSlotId] = _text.writeToBytecode();
+        // record written slot before incrementing
+        uint256 textSlotId = nextTextSlotId;
+        nextTextSlotId++;
+        return textSlotId;
+    }
+
+    /**
+     * @notice "Read": Reads chunk of text currently in the provided slot, from
+     *                 chain-state.
+     * @param _textSlotId Slot (associated with this contract) for which to
+     *                   read text content.
+     * @return string Content read from contract bytecode in the given slot.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readText(uint256 _textSlotId) public view returns (string memory) {
+        return
+            BytecodeStorageReader.readFromBytecode(
+                storedTextBytecodeAddresses[_textSlotId]
+            );
+    }
+
+    /**
+     * @notice "Delete": Deletes chunk of text currently in the provided slot,
+     *                   from chain-state.
+     * @param _textSlotId Slot (associated with this contract) for which to
+     *                    delete text content.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function deleteText(uint256 _textSlotId) external onlyDeployer {
+        // delete reference to old storage contract address
+        delete storedTextBytecodeAddresses[_textSlotId];
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                       Additional Introspection
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address.
+     * @param _bytecodeAddress address from which to read text content.
+     * @return string Content read from contract bytecode at the given address.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (string memory) {
+        return BytecodeStorageReader.readFromBytecode(_bytecodeAddress);
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address with an
+     *         explicitly provided `_offset`.
+     * @param _bytecodeAddress address from which to read text content.
+     * @param _offset Offset to read from in contract bytecode,
+     *                explicitly provided (not calculated)
+     * @return string Content read from contract bytecode at the given address.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function forceReadTextAtAddress(
+        address _bytecodeAddress,
+        uint256 _offset
+    ) public view returns (string memory) {
+        return
+            string(
+                BytecodeStorageReader.readBytesFromBytecode(
+                    _bytecodeAddress,
+                    _offset
+                )
+            );
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address that
+     *         was written with SSTORE2.
+     * @param _bytecodeAddress address from which to read text content.
+     * @return string Content read from contract bytecode at the given address.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readSSTORE2TextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (string memory) {
+        return
+            string(
+                BytecodeStorageReader.readBytesFromSSTORE2Bytecode(
+                    _bytecodeAddress
+                )
+            );
+    }
+
+    /**
+     * @notice Allows introspection of who deployed a given contracts-as-storage
+     *         contract, based on a provided `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to read the author address.
+     * @return address of the author who wrote the data contained in the
+     *                 given `_bytecodeAddress` contract.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readAuthorForTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (address) {
+        return
+            BytecodeStorageReader.getWriterAddressForBytecode(_bytecodeAddress);
+    }
+
+    /**
+     * @notice Allows introspection of the version of a given contracts-as-storage
+     *         contract, based on a provided `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to read the version.
+     * @return bytes32 version of the version string contained in the given `_bytecodeAddress`
+     *                 contract.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readLibraryVersionForTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (bytes32) {
+        return
+            BytecodeStorageReader.getLibraryVersionForBytecode(
+                _bytecodeAddress
+            );
+    }
+
+    /**
+     * @notice Allows additional internal purge-logic introspection, by allowing
+     *         for the sending of arbitrary data from this contract to the
+     *         provided existing `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to send call data.
+     * @param _data aribtrary data to send as call-data for raw `.call`.
+     * @dev WARNING - THIS IS NOT SECURE AND SHOULD NOT BE USED IN PRODUCTION.
+     */
+    function callWithNonsenseData(
+        address _bytecodeAddress,
+        bytes memory _data
+    ) external onlyDeployer {
+        (bool success /* `data` not needed */, ) = _bytecodeAddress.call(_data);
+        if (success) {
+            // WARNING - This implementation does not make use of the low-level
+            //           call return result indicating success/failure. This is
+            //           contrary to best practice but is OK in this instance as
+            //           this method IS NOT SECURE AND SHOULD NOT BE USED IN
+            //           PRODUCTION under any normal circumstances.
+        }
+    }
+
+    /**
+     * @notice Allows additional internal purge-logic introspection, by allowing
+     *         for the sending of raw calls (with no data) from this contract to
+     *         the provided existing `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to send call data.
+     * @dev WARNING - THIS IS NOT SECURE AND SHOULD NOT BE USED IN PRODUCTION.
+     */
+    function callWithoutData(address _bytecodeAddress) external onlyDeployer {
+        (bool success /* `data` not needed */, ) = _bytecodeAddress.call("");
+        if (success) {
+            // WARNING - This implementation does not make use of the low-level
+            //           call return result indicating success/failure. This is
+            //           contrary to best practice but is OK in this instance as
+            //           this method IS NOT SECURE AND SHOULD NOT BE USED IN
+            //           PRODUCTION under any normal circumstances.
+        }
+    }
+}

package/contracts/mock/DeadReceiverBidderMock.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 import {DeadReceiverMock} from "./DeadReceiverMock.sol";
 

package/contracts/mock/DeadReceiverMock.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 /**
  * @notice This reverts when receiving Ether

package/contracts/mock/DummySharedMinter.sol

@@ -0,0 +1,75 @@
+// 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/IMinterFilterV1.sol";
+
+pragma solidity 0.8.19;
+
+/**
+ * @title NON-PRODUCTION shared minter used for testing purposes only.
+ * In general, this is intended to integrate with IMinterFilterV1, and should
+ * be used for integration testing purposes only.
+ * @author Art Blocks Inc.
+ */
+contract DummySharedMinter {
+    /// 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 = "DummySharedMinter";
+
+    /// minter version for this minter
+    string public constant minterVersion = "v0.0.0";
+
+    uint256 constant ONE_MILLION = 1_000_000;
+
+    function _onlyArtist(
+        uint256 _projectId,
+        address _coreContract
+    ) internal view {
+        require(
+            msg.sender ==
+                IGenArt721CoreContractV3_Base(_coreContract)
+                    .projectIdToArtistAddress(_projectId),
+            "Only Artist"
+        );
+    }
+
+    /**
+     * @notice Initializes contract to be a Filtered Minter for
+     * `_minterFilter`.
+     * @param _minterFilter Minter filter for which this will be a
+     * filtered minter.
+     */
+    constructor(address _minterFilter) {
+        minterFilterAddress = _minterFilter;
+        minterFilter = IMinterFilterV1(_minterFilter);
+    }
+
+    function purchase(
+        uint256 _projectId,
+        address _coreContract
+    ) external payable returns (uint256 tokenId) {
+        tokenId = purchaseTo(msg.sender, _projectId, _coreContract);
+        return tokenId;
+    }
+
+    function purchaseTo(
+        address _to,
+        uint256 _projectId,
+        address _coreContract
+    ) public payable returns (uint256 tokenId) {
+        tokenId = minterFilter.mint_joo(
+            _to,
+            _projectId,
+            _coreContract,
+            msg.sender
+        );
+        // intentionally does not split funds to keep this dummy minter simple
+        return tokenId;
+    }
+}

package/contracts/mock/GasLimitReceiverBidderMock.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 import {GasLimitReceiverMock} from "./GasLimitReceiverMock.sol";
 

package/contracts/mock/GasLimitReceiverMock.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 /**
  * @notice This uses all gas when receiving Ether, useful when testing denial

package/contracts/mock/GenArt721CoreV3_Engine_IncorrectCoreType.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-only
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 // Created By: Art Blocks Inc.
 
@@ -13,7 +13,7 @@ import "../interfaces/0.8.x/IManifold.sol";
 import "@openzeppelin-4.7/contracts/utils/Strings.sol";
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";
 import "../libs/0.8.x/ERC721_PackedHashSeed.sol";
-import "../libs/0.8.x/BytecodeStorage.sol";
+import "../libs/0.8.x/BytecodeStorageV1.sol";
 import "../libs/0.8.x/Bytes32Strings.sol";
 
 /**
@@ -30,8 +30,7 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
     IManifold
     // INTERFACE CONFORMANCE INTENTIONALLY OMITTED TO ENABLE MOCKING BUGGED CONTRACT
 {
-    using BytecodeStorage for string;
-    using BytecodeStorage for address;
+    using BytecodeStorageWriter for string;
     using Bytes32Strings for bytes32;
     using Strings for uint256;
     using Strings for address;
@@ -1115,16 +1114,6 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
     {
         Project storage project = projects[_projectId];
         require(_scriptId < project.scriptCount, "scriptId out of range");
-        // purge old contract bytecode contract from the blockchain state
-        // note: Although this does reduce usage of Ethereum state, it does not
-        // reduce the gas costs of removal transactions. We believe this is the
-        // best behavior at the time of writing, and do not expect this to
-        // result in any breaking changes in the future. All current proposals
-        // to change the self-destruct opcode are backwards compatible, but may
-        // result in not removing the bytecode from the blockchain state. This
-        // implementation is compatible with that architecture, as it does not
-        // rely on the bytecode being removed from the blockchain state.
-        project.scriptBytecodeAddresses[_scriptId].purgeBytecode();
         // store script in contract bytecode, replacing reference address from
         // the contract that no longer exists with the newly created one
         project.scriptBytecodeAddresses[_scriptId] = _script.writeToBytecode();
@@ -1144,18 +1133,6 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
     {
         Project storage project = projects[_projectId];
         require(project.scriptCount > 0, "there are no scripts to remove");
-        // purge old contract bytecode contract from the blockchain state
-        // note: Although this does reduce usage of Ethereum state, it does not
-        // reduce the gas costs of removal transactions. We believe this is the
-        // best behavior at the time of writing, and do not expect this to
-        // result in any breaking changes in the future. All current proposals
-        // to change the self-destruct opcode are backwards compatible, but may
-        // result in not removing the bytecode from the blockchain state. This
-        // implementation is compatible with that architecture, as it does not
-        // rely on the bytecode being removed from the blockchain state.
-        project
-            .scriptBytecodeAddresses[project.scriptCount - 1]
-            .purgeBytecode();
         // delete reference to contract address that no longer exists
         delete project.scriptBytecodeAddresses[project.scriptCount - 1];
         unchecked {
@@ -1580,7 +1557,7 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
         if (_index >= project.scriptCount) {
             return "";
         }
-        return project.scriptBytecodeAddresses[_index].readFromBytecode();
+        return _readFromBytecode(project.scriptBytecodeAddresses[_index]);
     }
 
     /**
@@ -1976,4 +1953,14 @@ contract GenArt721CoreV3_Engine_IncorrectCoreType is
             (block.timestamp - projectCompletedTimestamp <
                 FOUR_WEEKS_IN_SECONDS);
     }
+
+    /**
+     * Helper for calling `BytecodeStorageReader` external library reader method,
+     * added for bytecode size reduction purposes.
+     */
+    function _readFromBytecode(
+        address _address
+    ) internal view returns (string memory) {
+        return BytecodeStorageReader.readFromBytecode(_address);
+    }
 }

package/contracts/mock/MockAdminACLV0.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: MIT
 
-pragma solidity 0.8.17;
+pragma solidity 0.8.19;
 
 import "../interfaces/0.8.x/IAdminACLV0.sol";
 import "@openzeppelin-4.7/contracts/access/Ownable.sol";