@artblocks/contracts 1.1.0 → 1.2.0

package/contracts/mock/BytecodeV2TextCR_DMock.sol

@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.19;
+
+// Created By: Art Blocks Inc.
+
+import {BytecodeStorageWriter, BytecodeStorageReader} from "../libs/v0.8.x/BytecodeStorageV2.sol";
+
+/**
+ * @title Art Blocks BytecodeTextCR_DMock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the BytecodeStorageV2 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 BytecodeStorageV2 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 BytecodeV2TextCR_DMock {
+    using BytecodeStorageWriter for string;
+    using BytecodeStorageReader for string;
+    using BytecodeStorageWriter for bytes;
+
+    // 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;
+
+    // dummy counter to implement non-view read function for gas measurements of large reads (RPC compatibility)
+    uint256 private _dummyCounter;
+
+    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 "Create": Adds a chunk of text to be stored to chain-state.
+     * @param _textCompressed Compressed bytes representing 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 createTextCompressed(
+        bytes memory _textCompressed
+    ) external onlyDeployer returns (uint256) {
+        // store compressed text in contract bytecode
+        storedTextBytecodeAddresses[nextTextSlotId] = _textCompressed
+            .writeToBytecodeCompressed();
+        // 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];
+    }
+
+    /**
+     * @notice function to assist in getting compressed text in a non-view function.
+     * Useful for measuring gas costs of large reads in RPC environments.
+     * @param _text Text to be compressed.
+     */
+    function getCompressedNonView(
+        string memory _text
+    ) external returns (bytes memory) {
+        // non-view dummy portion of the function
+        _dummyCounter++;
+        // read compressed text from chain-state
+        return _text.getCompressed();
+    }
+
+    /**
+     * @notice Allows additional read introspection, to read a chunk of text,
+     *         from chain-state that lives at a given deployed address.
+     *         Non-view variant to easily measure gas costs of large reads.
+     * @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 readTextNonView(
+        uint256 _textSlotId
+    ) external returns (string memory) {
+        // non-view dummy portion of the function
+        _dummyCounter++;
+        // read text from chain-state
+        return
+            BytecodeStorageReader.readFromBytecode(
+                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 introspection of if stored data are in compressed format of a given
+     *         contracts-as-storage contract, based on a provided `_bytecodeAddress`.
+     * @param _bytecodeAddress address for which to read the version.
+     * @return bool indicating if data are stored in compressed format in the given
+     *         `_bytecodeAddress` contract.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function readIsCompressedForTextAtAddress(
+        address _bytecodeAddress
+    ) public view returns (bool) {
+        return
+            BytecodeStorageReader.getIsCompressedForBytecode(_bytecodeAddress);
+    }
+
+    function getCompressed(
+        string memory _text
+    ) public pure returns (bytes memory) {
+        return _text.getCompressed();
+    }
+
+    /**
+     * @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/ForceSendMock.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.19;
+
+import {SplitFundsLib} from "../libs/v0.8.x/minter-libs/SplitFundsLib.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract exposes a payable function that force-sends ETH to a target
+ * address.
+ */
+contract ForceSendMock {
+    // @dev forwards msg.value to target address
+    function forceSendETH(address target) external payable {
+        SplitFundsLib.forceSafeTransferETH({
+            to: target,
+            amount: msg.value,
+            // induce force-send by having a low gas limit
+            minterRefundGasLimit: 1_000
+        });
+    }
+}

package/contracts/mock/Mock0xSplitsV2PullFactory.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.22;
+
+import "../interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+import {Mock0xSplitsV2Splitter} from "./Mock0xSplitsV2Splitter.sol";
+
+import {Create2} from "@openzeppelin-5.0/contracts/utils/Create2.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract implements a mock version of the splitter factory deployed
+ * by 0xSplits V2.
+ * Behaviors are not exactly the same as the production version of the contract
+ * and are implemented for integration and testing purposes.
+ */
+contract Mock0xSplitsV2PullFactory is ISplitFactoryV2 {
+    /**
+     * @notice Create a new split with params and owner.
+     * For testing purposes only.
+     * @dev This function is not implemented exactly like 0xSplits V2 factory, but is
+     * sufficient for testing purposes.
+     * @param _splitParams Params to create split with.
+     * @param _owner Owner of created split.
+     * @param _creator Creator of created split.
+     * @param _salt Salt for create2.
+     * @return split Address of the created split.
+     */
+    function createSplitDeterministic(
+        Split calldata _splitParams,
+        address _owner,
+        address _creator,
+        bytes32 _salt
+    ) external returns (address split) {
+        require(_creator != address(0), "Invalid creator");
+        // deploy + initialize
+        address newSplitter = Create2.deploy({
+            amount: 0,
+            salt: _getFakeMockHash(_splitParams, _owner, _salt),
+            bytecode: type(Mock0xSplitsV2Splitter).creationCode
+        });
+        Mock0xSplitsV2Splitter(newSplitter).initialize(_splitParams, _owner);
+        return newSplitter;
+    }
+
+    /**
+     * @notice Predict the address of a new split and check if it is deployed.
+     * For testing purposes only, namely, this function is not equivalent to the
+     * implementation shipped for 0xSplits V2, and is only for testing purposes.
+     * @param _splitParams Params to create split with.
+     * @param _owner Owner of created split.
+     * @param _salt Salt for create2.
+     */
+    function isDeployed(
+        Split calldata _splitParams,
+        address _owner,
+        bytes32 _salt
+    ) external view returns (address split, bool exists) {
+        address predictedSplitter = Create2.computeAddress({
+            salt: _getFakeMockHash(_splitParams, _owner, _salt),
+            bytecodeHash: keccak256(type(Mock0xSplitsV2Splitter).creationCode)
+        });
+        return (predictedSplitter, predictedSplitter.code.length > 0);
+    }
+
+    // this gets a fack hash with all split and owner params for testing purposes,
+    // and does not match 0xSplits implementation
+    function _getFakeMockHash(
+        Split memory splitParams,
+        address owner,
+        bytes32 salt
+    ) private pure returns (bytes32) {
+        return keccak256(abi.encode(splitParams, owner, salt));
+    }
+}

package/contracts/mock/Mock0xSplitsV2Splitter.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.22;
+
+import "../interfaces/v0.8.x/integration-refs/splits-0x-v2/ISplitFactoryV2.sol";
+
+/**
+ * @dev Mock contract for testing purposes.
+ * This contract implements a mock version of a splitter deployed
+ * by 0xSplits V2.
+ * Behaviors are not the same as the production version of the contract
+ * and are implemented for integration and testing purposes.
+ * Notably, this contract is not actually a splitter, but more of an introspection
+ * contract for testing purposes.
+ */
+contract Mock0xSplitsV2Splitter {
+    ISplitFactoryV2.Split private _splitParams;
+    address private _owner;
+    bool private _isInitialized;
+
+    function initialize(
+        ISplitFactoryV2.Split memory splitParams,
+        address owner
+    ) external {
+        _splitParams = splitParams;
+        _owner = owner;
+        _isInitialized = true;
+    }
+
+    function getSplitParams()
+        external
+        view
+        returns (ISplitFactoryV2.Split memory)
+    {
+        _onlyInitialized();
+        return _splitParams;
+    }
+
+    function getOwner() external view returns (address) {
+        _onlyInitialized();
+        return _owner;
+    }
+
+    function _onlyInitialized() private view {
+        require(_isInitialized, "Splitter not initialized");
+    }
+}

package/contracts/mock/MockAdminACLV0.sol

@@ -54,6 +54,27 @@ contract MockAdminACLV0Events is IAdminACLV0, ERC165 {
         Ownable(_contract).transferOwnership(_newAdminACL);
     }
 
+    /**
+     * @notice Allows superAdmin change the superAdmin address.
+     * @param _newSuperAdmin The new superAdmin address.
+     * @param _genArt721CoreAddressesToUpdate Array of genArt721Core
+     * addresses to update to the new superAdmin, for indexing purposes only.
+     * @dev this function is gated to only superAdmin address.
+     */
+    function changeSuperAdmin(
+        address _newSuperAdmin,
+        address[] calldata _genArt721CoreAddressesToUpdate
+    ) external {
+        require(msg.sender == superAdmin, "Only superAdmin");
+        address previousSuperAdmin = superAdmin;
+        superAdmin = _newSuperAdmin;
+        emit SuperAdminTransferred(
+            previousSuperAdmin,
+            _newSuperAdmin,
+            _genArt721CoreAddressesToUpdate
+        );
+    }
+
     /**
      * @dev Allows superAdmin to call renounceOwnership on other contract from
      * this contract.

package/contracts/mock/MockAdminACLV0_PROHIBITION.sol

@@ -63,6 +63,27 @@ contract MockAdminACLV0Events_PROHIBITION is IAdminACLV0_PROHIBITION, ERC165 {
             contractArtistApprovals[hashArtistApprovalKey(_contract, _caller)];
     }
 
+    /**
+     * @notice Allows superAdmin change the superAdmin address.
+     * @param _newSuperAdmin The new superAdmin address.
+     * @param _genArt721CoreAddressesToUpdate Array of genArt721Core
+     * addresses to update to the new superAdmin, for indexing purposes only.
+     * @dev this function is gated to only superAdmin address.
+     */
+    function changeSuperAdmin(
+        address _newSuperAdmin,
+        address[] calldata _genArt721CoreAddressesToUpdate
+    ) external {
+        require(msg.sender == superAdmin, "Only superAdmin");
+        address previousSuperAdmin = superAdmin;
+        superAdmin = _newSuperAdmin;
+        emit SuperAdminTransferred(
+            previousSuperAdmin,
+            _newSuperAdmin,
+            _genArt721CoreAddressesToUpdate
+        );
+    }
+
     /**
      * @dev Allows superAdmin to set a contract function caller.
      */

package/contracts/mock/ReentrancyGenArt721MinterMock.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/IGenArt721Minter_PBAB.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancyGenArt721MinterMock {
+    uint256 public currentQtyToPurchase;
+    uint256 public currentProjectId;
+    uint256 public currentPriceToPay;
+    address public currencyAddress;
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite. 
+        Note that _priceToPay should be > project price per token to induce refund, 
+        making reentrency possible via fallback function.
+     */
+    function attack(
+        uint256 _qtyToPurchase,
+        address _minterContractAddress,
+        uint256 _projectId,
+        uint256 _priceToPay,
+        address _currencyAddress
+    ) external payable {
+        currentQtyToPurchase = _qtyToPurchase;
+        currentProjectId = _projectId;
+        currentPriceToPay = _priceToPay;
+        currencyAddress = _currencyAddress;
+        IGenArt721Minter_PBAB(_minterContractAddress).purchase{
+            value: _priceToPay
+        }(_projectId, _priceToPay, _currencyAddress);
+    }
+
+    // receiver is called when minter sends refunded Ether to this contract.
+    receive() external payable {
+        // decrement num to be purchased
+        currentQtyToPurchase--;
+        if (currentQtyToPurchase > 0) {
+            // purchase again!
+            IGenArt721Minter_PBAB(msg.sender).purchase{
+                value: currentPriceToPay
+            }(currentProjectId, currentPriceToPay, currencyAddress);
+        }
+    }
+}

package/contracts/mock/ReentrancySplitterMocks.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../interfaces/v0.8.x/ISplitAtomicV0.sol";
+
+pragma solidity ^0.8.0;
+
+contract ReentrancySplitterSendETHMock {
+    address public currentSplitterAddress;
+    bool public haveReentered;
+
+    receive() external payable {
+        // only re-enter once to prevent infinite loop
+        if (haveReentered) {
+            return;
+        }
+        // update state
+        haveReentered = true;
+        // re-enter via sending ETH to splitter's receive function
+        (bool success, ) = currentSplitterAddress.call{value: msg.value}("");
+        require(success, "attack failed");
+        // reset state
+        haveReentered = false;
+    }
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite. 
+        Note that _priceToPay should be > project price per token to induce refund, 
+        making reentrency possible via fallback function.
+     */
+    function attack(address splitterAddress) external payable {
+        currentSplitterAddress = splitterAddress;
+        (bool success, ) = splitterAddress.call{value: msg.value}("");
+        require(success, "attack failed");
+    }
+}
+
+contract ReentrancySplitterDrainETHMock {
+    address public currentSplitterAddress;
+    bool public haveReentered;
+
+    receive() external payable {
+        // only re-enter once to prevent infinite loop
+        if (haveReentered) {
+            return;
+        }
+        // update state
+        haveReentered = true;
+        // re-enter via calling splitter's drainETH function
+        ISplitAtomicV0(currentSplitterAddress).drainETH();
+        // reset state
+        haveReentered = false;
+    }
+
+    /**
+        @notice This function can be called to induce controlled reentrency attacks
+        on AB minter filter suite. 
+        Note that _priceToPay should be > project price per token to induce refund, 
+        making reentrency possible via fallback function.
+     */
+    function attack(address splitterAddress) external payable {
+        currentSplitterAddress = splitterAddress;
+        (bool success, ) = splitterAddress.call{value: msg.value}("");
+        require(success, "attack failed");
+    }
+}

package/contracts/randomizer/primitive/PseudorandomAtomicBasic.sol

@@ -10,7 +10,7 @@ import "../../interfaces/v0.8.x/IPseudorandomAtomic.sol";
  * @author Art Blocks Inc.
  * @notice This contract atomically returns a pseudorandom value.
  */
-contract PseudorandomAtomic {
+contract PseudorandomAtomic is IPseudorandomAtomic {
     // base class that returns
     function getPseudorandomAtomic(
         bytes32 _entropy

package/contracts/randomizer/shared/SharedRandomizerV0.sol

@@ -248,7 +248,7 @@ contract SharedRandomizerV0 is ISharedRandomizerV0 {
     function _getPseudorandomAtomic(
         address coreContract,
         uint256 tokenId
-    ) internal view returns (bytes32) {
+    ) internal returns (bytes32) {
         return
             pseudorandomAtomicContract.getPseudorandomAtomic(
                 keccak256(abi.encodePacked(coreContract, tokenId))