@artblocks/contracts 1.0.1 → 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
@@ -76,13 +76,12 @@ contract MinterSetPriceERC20V4 is
     // /// projectId => currency address - supersedes any defined core value
     // mapping(uint256 => address) private projectIdToCurrencyAddress;
 
-    modifier onlyArtist(uint256 _projectId) {
+    function _onlyArtist(uint256 _projectId) internal view {
         require(
             msg.sender ==
                 genArtCoreContract_Base.projectIdToArtistAddress(_projectId),
             "Only Artist"
         );
-        _;
     }
 
     /**
@@ -151,9 +150,8 @@ contract MinterSetPriceERC20V4 is
      * @dev this enables gas reduction after maxInvocations have been reached -
      * core contracts shall still enforce a maxInvocation check during mint.
      */
-    function setProjectMaxInvocations(
-        uint256 _projectId
-    ) public onlyArtist(_projectId) {
+    function setProjectMaxInvocations(uint256 _projectId) public {
+        _onlyArtist(_projectId);
         uint256 maxInvocations;
         uint256 invocations;
         (invocations, maxInvocations, , , , ) = genArtCoreContract_Base
@@ -185,7 +183,8 @@ contract MinterSetPriceERC20V4 is
     function manuallyLimitProjectMaxInvocations(
         uint256 _projectId,
         uint256 _maxInvocations
-    ) external onlyArtist(_projectId) {
+    ) external {
+        _onlyArtist(_projectId);
         // CHECKS
         // ensure that the manually set maxInvocations is not greater than what is set on the core contract
         uint256 maxInvocations;
@@ -216,9 +215,8 @@ contract MinterSetPriceERC20V4 is
      * @notice Warning: Disabling purchaseTo is not supported on this minter.
      * This method exists purely for interface-conformance purposes.
      */
-    function togglePurchaseToDisabled(
-        uint256 _projectId
-    ) external view onlyArtist(_projectId) {
+    function togglePurchaseToDisabled(uint256 _projectId) external view {
+        _onlyArtist(_projectId);
         revert("Action not supported");
     }
 
@@ -273,7 +271,8 @@ contract MinterSetPriceERC20V4 is
     function updatePricePerTokenInWei(
         uint256 _projectId,
         uint256 _pricePerTokenInWei
-    ) external onlyArtist(_projectId) {
+    ) external {
+        _onlyArtist(_projectId);
         require(_pricePerTokenInWei > 0, "Price may not be 0");
         ProjectConfig storage _projectConfig = projectConfig[_projectId];
         _projectConfig.pricePerTokenInWei = _pricePerTokenInWei;
@@ -302,7 +301,8 @@ contract MinterSetPriceERC20V4 is
         uint256 _projectId,
         string memory _currencySymbol,
         address _currencyAddress
-    ) external onlyArtist(_projectId) {
+    ) external {
+        _onlyArtist(_projectId);
         // require null address if symbol is "ETH"
         require(
             (keccak256(abi.encodePacked(_currencySymbol)) ==

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.
@@ -61,13 +61,12 @@ contract MinterSetPriceV4 is ReentrancyGuard, MinterBase, IFilteredMinterV2 {
 
     mapping(uint256 => ProjectConfig) public projectConfig;
 
-    modifier onlyArtist(uint256 _projectId) {
+    function _onlyArtist(uint256 _projectId) internal view {
         require(
             msg.sender ==
                 genArtCoreContract_Base.projectIdToArtistAddress(_projectId),
             "Only Artist"
         );
-        _;
     }
 
     /**
@@ -104,9 +103,8 @@ contract MinterSetPriceV4 is ReentrancyGuard, MinterBase, IFilteredMinterV2 {
      * @dev this enables gas reduction after maxInvocations have been reached -
      * core contracts shall still enforce a maxInvocation check during mint.
      */
-    function setProjectMaxInvocations(
-        uint256 _projectId
-    ) public onlyArtist(_projectId) {
+    function setProjectMaxInvocations(uint256 _projectId) public {
+        _onlyArtist(_projectId);
         uint256 maxInvocations;
         uint256 invocations;
         (invocations, maxInvocations, , , , ) = genArtCoreContract_Base
@@ -138,7 +136,8 @@ contract MinterSetPriceV4 is ReentrancyGuard, MinterBase, IFilteredMinterV2 {
     function manuallyLimitProjectMaxInvocations(
         uint256 _projectId,
         uint256 _maxInvocations
-    ) external onlyArtist(_projectId) {
+    ) external {
+        _onlyArtist(_projectId);
         // CHECKS
         // ensure that the manually set maxInvocations is not greater than what is set on the core contract
         uint256 maxInvocations;
@@ -169,9 +168,8 @@ contract MinterSetPriceV4 is ReentrancyGuard, MinterBase, IFilteredMinterV2 {
      * @notice Warning: Disabling purchaseTo is not supported on this minter.
      * This method exists purely for interface-conformance purposes.
      */
-    function togglePurchaseToDisabled(
-        uint256 _projectId
-    ) external view onlyArtist(_projectId) {
+    function togglePurchaseToDisabled(uint256 _projectId) external view {
+        _onlyArtist(_projectId);
         revert("Action not supported");
     }
 
@@ -228,7 +226,8 @@ contract MinterSetPriceV4 is ReentrancyGuard, MinterBase, IFilteredMinterV2 {
     function updatePricePerTokenInWei(
         uint256 _projectId,
         uint256 _pricePerTokenInWei
-    ) external onlyArtist(_projectId) {
+    ) external {
+        _onlyArtist(_projectId);
         ProjectConfig storage _projectConfig = projectConfig[_projectId];
         _projectConfig.pricePerTokenInWei = _pricePerTokenInWei;
         _projectConfig.priceIsConfigured = true;

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

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+pragma solidity 0.8.19;
+
+import {DeadReceiverMock} from "./DeadReceiverMock.sol";
+
+/**
+ * @notice This reverts when receiving Ether.
+ * Also exposes a createBidOnAuction function to create a bid on an auction
+ * of a serial English auction minter.
+ * @dev Mock contract for testing purposes.
+ */
+contract DeadReceiverBidderMock is DeadReceiverMock {
+    function createBidOnAuction(
+        address minter,
+        uint256 tokenId
+    ) external payable {
+        (bool success, ) = minter.call{value: msg.value}(
+            abi.encodeWithSignature("createBid(uint256)", tokenId)
+        );
+        require(success, "DeadReceiverBidderMock: call failed");
+    }
+}

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

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+pragma solidity 0.8.19;
+
+import {GasLimitReceiverMock} from "./GasLimitReceiverMock.sol";
+
+/**
+ * @notice This reverts when receiving Ether.
+ * Also exposes a createBidOnAuction function to create a bid on an auction
+ * of a serial English auction minter.
+ * @dev Mock contract for testing purposes.
+ */
+contract GasLimitReceiverBidderMock is GasLimitReceiverMock {
+    function createBidOnAuction(
+        address minter,
+        uint256 tokenId
+    ) external payable {
+        (bool success, ) = minter.call{value: msg.value}(
+            abi.encodeWithSignature("createBid(uint256)", tokenId)
+        );
+        require(success, "GasLimitReceiverBidderMock: call failed");
+    }
+}

package/contracts/mock/GasLimitReceiverMock.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+pragma solidity 0.8.19;
+
+/**
+ * @notice This uses all gas when receiving Ether, useful when testing denial
+ * of service attacks.
+ * @dev Mock contract for testing purposes.
+ */
+contract GasLimitReceiverMock {
+    string public a = "a string in storage.";
+
+    receive() external payable {
+        // infinite loop to burn all available gas
+        while (true) {
+            a = string.concat(a, " A longer string in storage to burn gas.");
+        }
+    }
+}