@artblocks/contracts 0.0.1

package/contracts/minter-suite/Minters/MinterSetPriceERC20/deprecated/MinterSetPriceERC20V0.sol

@@ -0,0 +1,470 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// Created By: Art Blocks Inc.
+
+import "../../../../interfaces/0.8.x/IGenArt721CoreContractV1.sol";
+import "../../../../interfaces/0.8.x/IMinterFilterV0.sol";
+import "../../../../interfaces/0.8.x/IFilteredMinterV0.sol";
+
+import "@openzeppelin-4.5/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin-4.5/contracts/security/ReentrancyGuard.sol";
+
+pragma solidity 0.8.9;
+
+/**
+ * @title Filtered Minter contract that allows tokens to be minted with ETH
+ * or any ERC-20 token.
+ * @author Art Blocks Inc.
+ */
+contract MinterSetPriceERC20V0 is ReentrancyGuard, IFilteredMinterV0 {
+    /// Core contract address this minter interacts with
+    address public immutable genArt721CoreAddress;
+
+    /// This contract handles cores with interface IV1
+    IGenArt721CoreContractV1 private immutable genArtCoreContract;
+
+    /// Minter filter address this minter interacts with
+    address public immutable minterFilterAddress;
+
+    /// Minter filter this minter may interact with.
+    IMinterFilterV0 private immutable minterFilter;
+
+    /// minterType for this minter
+    string public constant minterType = "MinterSetPriceERC20V0";
+
+    uint256 constant ONE_MILLION = 1_000_000;
+
+    /// projectId => are contracts allowed to mint?
+    mapping(uint256 => bool) public contractMintable;
+    /// projectId => are tokens allowed to be minted to other addresses?
+    mapping(uint256 => bool) public purchaseToDisabled;
+    /// purchaser address => projectId => number of mints purchased
+    mapping(address => mapping(uint256 => uint256)) public projectMintCounter;
+    /// projectId => maximum number of mints a given address may invoke
+    mapping(uint256 => uint256) public projectMintLimit;
+    /// projectId => has project reached its maximum number of invocations?
+    mapping(uint256 => bool) public projectMaxHasBeenInvoked;
+    /// projectId => project's maximum number of invocations
+    mapping(uint256 => uint256) public projectMaxInvocations;
+    /// projectId => price per token in wei - supersedes any defined core price
+    mapping(uint256 => uint256) private projectIdToPricePerTokenInWei;
+    /// projectId => price per token has been configured on this minter
+    mapping(uint256 => bool) private projectIdToPriceIsConfigured;
+    /// projectId => currency symbol - supersedes any defined core value
+    mapping(uint256 => string) private projectIdToCurrencySymbol;
+    /// projectId => currency address - supersedes any defined core value
+    mapping(uint256 => address) private projectIdToCurrencyAddress;
+
+    modifier onlyCoreWhitelisted() {
+        require(
+            genArtCoreContract.isWhitelisted(msg.sender),
+            "Only Core whitelisted"
+        );
+        _;
+    }
+
+    modifier onlyArtist(uint256 _projectId) {
+        require(
+            msg.sender ==
+                genArtCoreContract.projectIdToArtistAddress(_projectId),
+            "Only Artist"
+        );
+        _;
+    }
+
+    /**
+     * @notice Initializes contract to be a Filtered Minter for
+     * `_minterFilter`, integrated with Art Blocks core contract
+     * at address `_genArt721Address`.
+     * @param _genArt721Address Art Blocks core contract for which this
+     * contract will be a minter.
+     * @param _minterFilter Minter filter for which
+     * this will a filtered minter.
+     */
+    constructor(
+        address _genArt721Address,
+        address _minterFilter
+    ) ReentrancyGuard() {
+        genArt721CoreAddress = _genArt721Address;
+        genArtCoreContract = IGenArt721CoreContractV1(_genArt721Address);
+        minterFilterAddress = _minterFilter;
+        minterFilter = IMinterFilterV0(_minterFilter);
+        require(
+            minterFilter.genArt721CoreAddress() == _genArt721Address,
+            "Illegal contract pairing"
+        );
+    }
+
+    /**
+     * @notice Gets your balance of the ERC-20 token currently set
+     * as the payment currency for project `_projectId`.
+     * @param _projectId Project ID to be queried.
+     * @return balance Balance of ERC-20
+     */
+    function getYourBalanceOfProjectERC20(
+        uint256 _projectId
+    ) external view returns (uint256 balance) {
+        balance = IERC20(projectIdToCurrencyAddress[_projectId]).balanceOf(
+            msg.sender
+        );
+        return balance;
+    }
+
+    /**
+     * @notice Gets your allowance for this minter of the ERC-20
+     * token currently set as the payment currency for project
+     * `_projectId`.
+     * @param _projectId Project ID to be queried.
+     * @return remaining Remaining allowance of ERC-20
+     */
+    function checkYourAllowanceOfProjectERC20(
+        uint256 _projectId
+    ) external view returns (uint256 remaining) {
+        remaining = IERC20(projectIdToCurrencyAddress[_projectId]).allowance(
+            msg.sender,
+            address(this)
+        );
+        return remaining;
+    }
+
+    /**
+     * @notice Sets the mint limit of a single purchaser for project
+     * `_projectId` to `_limit`.
+     * @param _projectId Project ID to set the mint limit for.
+     * @param _limit Number of times a given address may mint the
+     * project's tokens.
+     */
+    function setProjectMintLimit(
+        uint256 _projectId,
+        uint8 _limit
+    ) external onlyCoreWhitelisted {
+        projectMintLimit[_projectId] = _limit;
+    }
+
+    /**
+     * @notice Sets the 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.
+     * @dev also checks and may refresh projectMaxHasBeenInvoked for project
+     * @dev this enables gas reduction after maxInvocations have been reached -
+     * core contracts shall still enforce a maxInvocation check during mint.
+     */
+    function setProjectMaxInvocations(
+        uint256 _projectId
+    ) external onlyCoreWhitelisted {
+        uint256 invocations;
+        uint256 maxInvocations;
+        (, , invocations, maxInvocations, , , , , ) = genArtCoreContract
+            .projectTokenInfo(_projectId);
+        // update storage with results
+        projectMaxInvocations[_projectId] = maxInvocations;
+        if (invocations < maxInvocations) {
+            projectMaxHasBeenInvoked[_projectId] = false;
+        }
+    }
+
+    /**
+     * @notice Toggles if contracts are allowed to mint tokens for
+     * project `_projectId`.
+     * @param _projectId Project ID to be toggled.
+     */
+    function toggleContractMintable(
+        uint256 _projectId
+    ) external onlyCoreWhitelisted {
+        contractMintable[_projectId] = !contractMintable[_projectId];
+    }
+
+    /**
+     * @notice Toggles if purchases to other address are enabled for
+     * project `_projectId`.
+     * @param _projectId Project ID to be toggled.
+     */
+    function togglePurchaseToDisabled(
+        uint256 _projectId
+    ) external onlyCoreWhitelisted {
+        purchaseToDisabled[_projectId] = !purchaseToDisabled[_projectId];
+        emit PurchaseToDisabledUpdated(
+            _projectId,
+            purchaseToDisabled[_projectId]
+        );
+    }
+
+    /**
+     * @notice Updates this minter's price per token of project `_projectId`
+     * to be '_pricePerTokenInWei`, in Wei.
+     * This price supersedes any legacy core contract price per token value.
+     */
+    function updatePricePerTokenInWei(
+        uint256 _projectId,
+        uint256 _pricePerTokenInWei
+    ) external onlyArtist(_projectId) {
+        projectIdToPricePerTokenInWei[_projectId] = _pricePerTokenInWei;
+        projectIdToPriceIsConfigured[_projectId] = true;
+        emit PricePerTokenInWeiUpdated(_projectId, _pricePerTokenInWei);
+    }
+
+    /**
+     * @notice Updates payment currency of project `_projectId` to be
+     * `_currencySymbol` at address `_currencyAddress`.
+     * @param _projectId Project ID to update.
+     * @param _currencySymbol Currency symbol.
+     * @param _currencyAddress Currency address.
+     */
+    function updateProjectCurrencyInfo(
+        uint256 _projectId,
+        string memory _currencySymbol,
+        address _currencyAddress
+    ) external onlyArtist(_projectId) {
+        // require null address if symbol is "ETH"
+        require(
+            (keccak256(abi.encodePacked(_currencySymbol)) ==
+                keccak256(abi.encodePacked("ETH"))) ==
+                (_currencyAddress == address(0)),
+            "ETH is only null address"
+        );
+        projectIdToCurrencySymbol[_projectId] = _currencySymbol;
+        projectIdToCurrencyAddress[_projectId] = _currencyAddress;
+        emit ProjectCurrencyInfoUpdated(
+            _projectId,
+            _currencyAddress,
+            _currencySymbol
+        );
+    }
+
+    /**
+     * @notice Purchases a token from project `_projectId`.
+     * @param _projectId Project ID to mint a token on.
+     * @return tokenId Token ID of minted token
+     */
+    function purchase(
+        uint256 _projectId
+    ) external payable returns (uint256 tokenId) {
+        tokenId = purchaseTo(msg.sender, _projectId);
+        return tokenId;
+    }
+
+    /**
+     * @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.
+     * @return tokenId Token ID of minted token
+     */
+    function purchaseTo(
+        address _to,
+        uint256 _projectId
+    ) public payable nonReentrant returns (uint256 tokenId) {
+        // CHECKS
+        require(
+            !projectMaxHasBeenInvoked[_projectId],
+            "Maximum number of invocations reached"
+        );
+
+        // require artist to have configured price of token on this minter
+        require(
+            projectIdToPriceIsConfigured[_projectId],
+            "Price not configured"
+        );
+
+        // if contract filter is off, allow calls from another contract
+        if (!contractMintable[_projectId]) {
+            require(msg.sender == tx.origin, "No Contract Buys");
+        }
+
+        // if purchaseTo is disabled, enforce purchase destination to be the TX
+        // sending address.
+        if (purchaseToDisabled[_projectId]) {
+            require(msg.sender == _to, "No `purchaseTo` Allowed");
+        }
+
+        // limit mints per address by project
+        if (projectMintLimit[_projectId] > 0) {
+            require(
+                projectMintCounter[msg.sender][_projectId] <
+                    projectMintLimit[_projectId],
+                "Reached minting limit"
+            );
+            // EFFECTS
+            projectMintCounter[msg.sender][_projectId]++;
+        }
+
+        tokenId = minterFilter.mint(_to, _projectId, msg.sender);
+        // what if projectMaxInvocations[_projectId] is 0 (default value)?
+        // that is intended, so that by default the minter allows infinite transactions,
+        // allowing the artblocks contract to stop minting
+        // uint256 tokenInvocation = tokenId % ONE_MILLION;
+        if (
+            projectMaxInvocations[_projectId] > 0 &&
+            tokenId % ONE_MILLION == projectMaxInvocations[_projectId] - 1
+        ) {
+            projectMaxHasBeenInvoked[_projectId] = true;
+        }
+
+        // INTERACTIONS
+        if (projectIdToCurrencyAddress[_projectId] != address(0)) {
+            require(
+                msg.value == 0,
+                "this project accepts a different currency and cannot accept ETH"
+            );
+            require(
+                IERC20(projectIdToCurrencyAddress[_projectId]).allowance(
+                    msg.sender,
+                    address(this)
+                ) >= projectIdToPricePerTokenInWei[_projectId],
+                "Insufficient Funds Approved for TX"
+            );
+            require(
+                IERC20(projectIdToCurrencyAddress[_projectId]).balanceOf(
+                    msg.sender
+                ) >= projectIdToPricePerTokenInWei[_projectId],
+                "Insufficient balance."
+            );
+            _splitFundsERC20(_projectId);
+        } else {
+            require(
+                msg.value >= projectIdToPricePerTokenInWei[_projectId],
+                "Must send minimum value to mint!"
+            );
+            _splitFundsETH(_projectId);
+        }
+
+        return tokenId;
+    }
+
+    /**
+     * @dev splits ETH funds between sender (if refund), foundation,
+     * artist, and artist's additional payee for a token purchased on
+     * project `_projectId`.
+     * @dev utilizes transfer() to send ETH, so access lists may need to be
+     * populated when purchasing tokens.
+     */
+    function _splitFundsETH(uint256 _projectId) internal {
+        if (msg.value > 0) {
+            uint256 pricePerTokenInWei = projectIdToPricePerTokenInWei[
+                _projectId
+            ];
+            uint256 refund = msg.value - pricePerTokenInWei;
+            if (refund > 0) {
+                (bool success_, ) = msg.sender.call{value: refund}("");
+                require(success_, "Refund failed");
+            }
+            uint256 foundationAmount = (pricePerTokenInWei *
+                genArtCoreContract.artblocksPercentage()) / 100;
+            if (foundationAmount > 0) {
+                (bool success_, ) = genArtCoreContract.artblocksAddress().call{
+                    value: foundationAmount
+                }("");
+                require(success_, "Foundation payment failed");
+            }
+            uint256 projectFunds = pricePerTokenInWei - foundationAmount;
+            uint256 additionalPayeeAmount;
+            if (
+                genArtCoreContract.projectIdToAdditionalPayeePercentage(
+                    _projectId
+                ) > 0
+            ) {
+                additionalPayeeAmount =
+                    (projectFunds *
+                        genArtCoreContract.projectIdToAdditionalPayeePercentage(
+                            _projectId
+                        )) /
+                    100;
+                if (additionalPayeeAmount > 0) {
+                    (bool success_, ) = genArtCoreContract
+                        .projectIdToAdditionalPayee(_projectId)
+                        .call{value: additionalPayeeAmount}("");
+                    require(success_, "Additional payment failed");
+                }
+            }
+            uint256 creatorFunds = projectFunds - additionalPayeeAmount;
+            if (creatorFunds > 0) {
+                (bool success_, ) = genArtCoreContract
+                    .projectIdToArtistAddress(_projectId)
+                    .call{value: creatorFunds}("");
+                require(success_, "Artist payment failed");
+            }
+        }
+    }
+
+    /**
+     * @dev splits ERC-20 funds between foundation, artist, and artist's
+     * additional payee, for a token purchased on project `_projectId`.
+     */
+    function _splitFundsERC20(uint256 _projectId) internal {
+        uint256 pricePerTokenInWei = projectIdToPricePerTokenInWei[_projectId];
+        uint256 foundationAmount = (pricePerTokenInWei *
+            genArtCoreContract.artblocksPercentage()) / 100;
+        if (foundationAmount > 0) {
+            IERC20(projectIdToCurrencyAddress[_projectId]).transferFrom(
+                msg.sender,
+                genArtCoreContract.artblocksAddress(),
+                foundationAmount
+            );
+        }
+        uint256 projectFunds = pricePerTokenInWei - foundationAmount;
+        uint256 additionalPayeeAmount;
+        if (
+            genArtCoreContract.projectIdToAdditionalPayeePercentage(
+                _projectId
+            ) > 0
+        ) {
+            additionalPayeeAmount =
+                (projectFunds *
+                    genArtCoreContract.projectIdToAdditionalPayeePercentage(
+                        _projectId
+                    )) /
+                100;
+            if (additionalPayeeAmount > 0) {
+                IERC20(projectIdToCurrencyAddress[_projectId]).transferFrom(
+                    msg.sender,
+                    genArtCoreContract.projectIdToAdditionalPayee(_projectId),
+                    additionalPayeeAmount
+                );
+            }
+        }
+        uint256 creatorFunds = projectFunds - additionalPayeeAmount;
+        if (creatorFunds > 0) {
+            IERC20(projectIdToCurrencyAddress[_projectId]).transferFrom(
+                msg.sender,
+                genArtCoreContract.projectIdToArtistAddress(_projectId),
+                creatorFunds
+            );
+        }
+    }
+
+    /**
+     * @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. Supersedes any core contract price information.
+     * @param _projectId Project ID to get price information for.
+     * @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. "ETH" reserved for ether.
+     * @return currencyAddress currency address for purchases of project on
+     * this minter. Null address reserved for ether.
+     */
+    function getPriceInfo(
+        uint256 _projectId
+    )
+        external
+        view
+        returns (
+            bool isConfigured,
+            uint256 tokenPriceInWei,
+            string memory currencySymbol,
+            address currencyAddress
+        )
+    {
+        isConfigured = projectIdToPriceIsConfigured[_projectId];
+        tokenPriceInWei = projectIdToPricePerTokenInWei[_projectId];
+        currencyAddress = projectIdToCurrencyAddress[_projectId];
+        if (currencyAddress == address(0)) {
+            // defaults to ETH
+            currencySymbol = "ETH";
+        } else {
+            currencySymbol = projectIdToCurrencySymbol[_projectId];
+        }
+    }
+}

package/contracts/mock/BytecodeTextCR_DMock.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity 0.8.17;
+
+// Created By: Art Blocks Inc.
+
+import "../libs/0.8.x/BytecodeStorage.sol";
+
+/**
+ * @title Art Blocks BytecodeTextCR_DMock.
+ * @author Art Blocks Inc.
+ * @notice This contract serves as a mock client of the BytecodeStorage 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
+ *         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 BytecodeTextCR_DMock {
+    using BytecodeStorage for string;
+    using BytecodeStorage for address;
+
+    // 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 storedTextBytecodeAddresses[_textSlotId].readFromBytecode();
+    }
+
+    /**
+     * @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 {
+        // purge old contract bytecode contract from the blockchain state
+        storedTextBytecodeAddresses[_textSlotId].purgeBytecode();
+        // delete reference to contract address that no longer exists
+        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 _bytecodeAddress.readFromBytecode();
+    }
+
+    /**
+     * @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 _bytecodeAddress.getWriterAddressForBytecode();
+    }
+
+    /**
+     * @notice Allows additional delete introspection, to delete a chunk of text,
+     *                from chain-state that lives at a given deployed address.
+     * @param _bytecodeAddress address from which to delete text content.
+     * @dev Intentionally do not perform input validation, instead allowing
+     *      the underlying BytecodeStorage lib to throw errors where applicable.
+     */
+    function deleteTextAtAddress(
+        address _bytecodeAddress
+    ) external onlyDeployer {
+        // purge old contract bytecode contract from the blockchain state
+        _bytecodeAddress.purgeBytecode();
+    }
+
+    /**
+     * @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/DeadReceiverMock.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+
+pragma solidity 0.8.17;
+
+/**
+ * @notice This reverts when receiving Ether
+ * @dev Mock contract for testing purposes.
+ */
+contract DeadReceiverMock {
+    receive() external payable {
+        revert("DeadReceiverMock: I am dead");
+    }
+}

package/contracts/mock/ERC20Mock.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin-4.5/contracts/token/ERC20/ERC20.sol";
+
+contract ERC20Mock is ERC20 {
+    constructor(uint256 initialSupply) ERC20("Mock Token", "MOCK") {
+        _mint(msg.sender, initialSupply);
+    }
+}