Initial forge tests

contracts/token/erc721/interfaces/IImmutableERC721.sol

@@ -0,0 +1,108 @@
+// Copyright Immutable Pty Ltd 2018 - 2023
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+
+
+interface IImmutableERC721 is IERC721, IERC721Metadata {
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721TokenAlreadyBurned(uint256 tokenId);
+
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721SendingToZerothAddress();
+
+    /// @dev Caller tried to mint an already burned token
+    error IImmutableERC721MismatchedTransferLengths();
+
+    /// @dev Caller tried to mint a tokenid that is above the hybrid threshold
+    error IImmutableERC721IDAboveThreshold(uint256 tokenId);
+
+    /// @dev Caller is not approved or owner
+    error IImmutableERC721NotOwnerOrOperator(uint256 tokenId);
+
+    /// @dev Current token owner is not what was expected
+    error IImmutableERC721MismatchedTokenOwner(uint256 tokenId, address currentOwner);
+
+    /// @dev Signer is zeroth address
+    error SignerCannotBeZerothAddress();
+
+    /// @dev Deadline exceeded for permit
+    error PermitExpired();
+
+    /// @dev Derived signature is invalid (EIP721 and EIP1271)
+    error InvalidSignature();
+
+
+    /**
+     * @notice A singular batch transfer request. The length of the tos and tokenIds must be matching
+     *  batch transfers will transfer the specified ids to their matching address via index.
+     *
+     */
+    struct TransferRequest {
+        address from;
+        address[] tos;
+        uint256[] tokenIds;
+    }
+
+    /// @notice A singular safe burn request.
+    struct IDBurn {
+        address owner;
+        uint256[] tokenIds;
+    }
+
+    /// @notice A singular Mint by quantity request
+    struct Mint {
+        address to;
+        uint256 quantity;
+    }
+
+    /// @notice A singular Mint by id request
+    struct IDMint {
+        address to;
+        uint256[] tokenIds;
+    }
+
+
+    /**
+     * @notice Allows minter to mint a token by ID to a specified address
+     *  @param to the address to mint the token to
+     *  @param tokenId the ID of the token to mint
+     */
+    function mint(address to, uint256 tokenId) external;
+
+    /**
+     * @notice Allows minter to mint a token by ID to a specified address with hooks and checks
+     *  @param to the address to mint the token to
+     *  @param tokenId the ID of the token to mint
+     */
+    function safeMint(address to, uint256 tokenId) external;
+
+    /**
+     * @notice Allows minter to safe mint a number of tokens by ID to a number of specified
+     *  addresses with hooks and checks. Check ERC721Hybrid for details on _mintBatchByIDToMultiple
+     *  @param mints the list of IDMint struct containing the to, and tokenIds
+     */
+    function mintBatch(IDMint[] calldata mints) external;
+
+    /**
+     * @notice Allows minter to safe mint a number of tokens by ID to a number of specified
+     *  addresses with hooks and checks. Check ERC721Hybrid for details on _safeMintBatchByIDToMultiple
+     *  @param mints the list of IDMint struct containing the to, and tokenIds
+     */
+    function safeMintBatch(IDMint[] calldata mints) external;
+
+    /**
+     * @notice Allows caller to a burn a number of tokens by ID from a specified address
+     *  @param burns the IDBurn struct containing the to, and tokenIds
+     */
+    function safeBurnBatch(IDBurn[] calldata burns) external;
+
+    /**
+     * @notice Allows caller to a transfer a number of tokens by ID from a specified
+     *  address to a number of specified addresses
+     *  @param tr the TransferRequest struct containing the from, tos, and tokenIds
+     */
+    function safeTransferFromBatch(TransferRequest calldata tr) external;
+}

contracts/token/erc721/interfaces/IImmutableERC721ByQuantity.sol

@@ -0,0 +1,41 @@
+// Copyright Immutable Pty Ltd 2018 - 2023
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity 0.8.19;
+
+import {IImmutableERC721} from "./IImmutableERC721.sol";
+
+interface IImmutableERC721ByQuantity is IImmutableERC721 {
+    /**
+     * @notice Allows minter to mint a number of tokens sequentially to a specified address
+     *  @param to the address to mint the token to
+     *  @param quantity the number of tokens to mint
+     */
+    function mintByQuantity(address to, uint256 quantity) external;
+
+    /**
+     * @notice Allows minter to mint a number of tokens sequentially to a specified address with hooks
+     *  and checks
+     *  @param to the address to mint the token to
+     *  @param quantity the number of tokens to mint
+     */
+    function safeMintByQuantity(address to, uint256 quantity) external;
+
+    /**
+     * @notice Allows minter to mint a number of tokens sequentially to a number of specified addresses
+     *  @param mints the list of Mint struct containing the to, and the number of tokens to mint
+     */
+    function mintBatchByQuantity(Mint[] calldata mints) external;
+
+    /**
+     * @notice Allows minter to safe mint a number of tokens sequentially to a number of specified addresses
+     *  @param mints the list of Mint struct containing the to, and the number of tokens to mint
+     */
+    function safeMintBatchByQuantity(Mint[] calldata mints) external;
+
+    /**
+     * @notice checks to see if tokenID exists in the collection
+     *  @param tokenId the id of the token to check
+     *
+     */
+    function exists(uint256 tokenId) external view returns (bool);
+}

test/token/erc721/ERC721Base.t.sol

@@ -0,0 +1,46 @@
+// Copyright Immutable Pty Ltd 2018 - 2025
+// SPDX-License-Identifier: Apache 2.0
+
+pragma solidity ^0.8.19;
+
+// solhint-disable-next-line no-global-import
+import "forge-std/Test.sol";
+import {IImmutableERC721} from "../../../contracts/token/erc721/interfaces/IImmutableERC721.sol";
+import {OperatorAllowlistUpgradeable} from "../../../contracts/allowlist/OperatorAllowlistUpgradeable.sol";
+import {DeployOperatorAllowlist} from "../../utils/DeployAllowlistProxy.sol";
+
+
+/**
+ * Base contract for all ERC 721 tests.
+ */
+abstract contract ERC721BaseTest is Test {
+    IImmutableERC721 public erc721;
+
+    OperatorAllowlistUpgradeable public allowlist;
+
+    address public owner;
+    address public feeReceiver;
+    address public operatorAllowListAdmin;
+    address public operatorAllowListUpgrader;
+    address public operatorAllowListRegistrar;
+
+    string public name;
+    string public symbol;
+    string public baseURI;
+    string public contractURI;
+    address public royaltyReceiver;
+    uint96 public feeNumerator;
+
+    function setUp() public virtual {
+        owner = makeAddr("hubOwner");
+        feeReceiver = makeAddr("feeReceiver");
+        name = "ERC721Preset";
+        symbol = "EP";
+        baseURI = "https://baseURI.com/";
+        contractURI = "https://contractURI.com";
+
+        DeployOperatorAllowlist deployScript = new DeployOperatorAllowlist();
+        address proxyAddr = deployScript.run(operatorAllowListAdmin, operatorAllowListUpgrader, operatorAllowListRegistrar);
+        allowlist = OperatorAllowlistUpgradeable(proxyAddr);
+    }
+}

test/token/erc721/ERC721ByQuantityBase.t.sol

@@ -0,0 +1,19 @@
+// Copyright Immutable Pty Ltd 2018 - 2025
+// SPDX-License-Identifier: Apache 2.0
+
+pragma solidity ^0.8.19;
+
+import {ERC721BaseTest} from "./ERC721Base.t.sol";
+import {IImmutableERC721ByQuantity} from "../../../contracts/token/erc721/interfaces/IImmutableERC721ByQuantity.sol";
+
+
+/**
+ * Base contract for all ERC 721 by quantity tests.
+ */
+abstract contract ERC721ByQuantityBaseTest is ERC721BaseTest {
+    IImmutableERC721ByQuantity public erc721BQ;
+
+    function setUp() public virtual override {
+        super.setUp();
+    }
+}

test/token/erc721/ERC721ByQuantityPerf.t.sol

@@ -0,0 +1,20 @@
+// Copyright Immutable Pty Ltd 2018 - 2025
+// SPDX-License-Identifier: Apache 2.0
+
+pragma solidity ^0.8.19;
+
+import {ERC721ByQuantityBaseTest} from "./ERC721ByQuantityBase.t.sol";
+
+
+/**
+ * Contract for all ERC 721 by quantity perfromance tests.
+ */
+abstract contract ERC721ByQuantityPerfTest is ERC721ByQuantityBaseTest {
+
+    function setUp() public virtual override {
+        super.setUp();
+    }
+
+
+
+}

test/token/erc721/ImmutableERC721ByQuantityPerf.t.sol

@@ -0,0 +1,25 @@
+// Copyright Immutable Pty Ltd 2018 - 2025
+// SPDX-License-Identifier: Apache 2.0
+
+pragma solidity ^0.8.19;
+
+import {ERC721ByQuantityPerfTest} from "./ERC721ByQuantityPerf.t.sol";
+import {ImmutableERC721} from "../../../contracts/token/erc721/preset/ImmutableERC721.sol";
+import {IImmutableERC721ByQuantity} from "../../../contracts/token/erc721/interfaces/IImmutableERC721ByQuantity.sol";
+
+/**
+ * Contract for ERC 721 by quantity perfromance tests, for ImmutableERC721.sol (that is, v1).
+ */
+contract ImmutableERC721ByQuantityPerfTest is ERC721ByQuantityPerfTest {
+    function setUp() public override {
+        super.setUp();
+
+        ImmutableERC721 immutableERC721 = new ImmutableERC721(
+            owner, name, symbol, baseURI, contractURI, address(allowlist), feeReceiver, 300
+        );
+
+        // ImmutableERC721 does not implement the interface, and hence must be cast to the 
+        // interface type.
+        erc721BQ = IImmutableERC721ByQuantity(address(immutableERC721));
+    }
+}