test(ctb): ERC721 factory tests

Ports the old hardhat tests for the OptimismMintableERC721Factory to
Foundry in contracts-bedrock.

packages/contracts-bedrock/.gas-snapshot

@@ -230,6 +230,11 @@ OptimismMintableERC721_Test:test_constructor_succeeds() (gas: 24162)
 OptimismMintableERC721_Test:test_safeMint_notBridge_reverts() (gas: 11142)
 OptimismMintableERC721_Test:test_safeMint_succeeds() (gas: 140502)
 OptimismMintableERC721_Test:test_tokenURI_succeeds() (gas: 163420)
+OptimismMintableERC721Factory_Test:test_constructor_succeeds() (gas: 9983)
+OptimismMintableERC721Factory_Test:test_constructor_zeroBridge_reverts() (gas: 39114)
+OptimismMintableERC721Factory_Test:test_constructor_zeroRemoteChainId_reverts() (gas: 41265)
+OptimismMintableERC721Factory_Test:test_createOptimismMintableERC721_succeeds() (gas: 2276418)
+OptimismMintableERC721Factory_Test:test_createOptimismMintableERC721_zeroRemoteToken_reverst() (gas: 9395)
 OptimismPortalUpgradeable_Test:test_initialize_cannotInitImpl_reverts() (gas: 10791)
 OptimismPortalUpgradeable_Test:test_initialize_cannotInitProxy_reverts() (gas: 15833)
 OptimismPortalUpgradeable_Test:test_params_initValuesOnProxy_succeeds() (gas: 16011)

packages/contracts-bedrock/contracts/test/CommonTest.t.sol

@@ -420,31 +420,25 @@ contract Bridge_Initializer is Messenger_Initializer {
 contract ERC721Bridge_Initializer is Messenger_Initializer {
     L1ERC721Bridge L1Bridge;
     L2ERC721Bridge L2Bridge;
-    OptimismMintableERC721Factory factory;
 
     function setUp() public virtual override {
         super.setUp();
 
+        // Deploy the L1ERC721Bridge.
         L1Bridge = new L1ERC721Bridge(address(L1Messenger), Predeploys.L2_ERC721_BRIDGE);
 
-        L2ERC721Bridge l2b = new L2ERC721Bridge(
+        // Deploy the implementation for the L2ERC721Bridge and etch it into the predeploy address.
+        vm.etch(Predeploys.L2_ERC721_BRIDGE, address(new L2ERC721Bridge(
             Predeploys.L2_CROSS_DOMAIN_MESSENGER,
             address(L1Bridge)
-        );
+        )).code);
 
-        vm.etch(Predeploys.L2_ERC721_BRIDGE, address(l2b).code);
+        // Set up a reference to the L2ERC721Bridge.
         L2Bridge = L2ERC721Bridge(Predeploys.L2_ERC721_BRIDGE);
 
-        OptimismMintableERC721Factory f = new OptimismMintableERC721Factory(
-            Predeploys.L2_ERC721_BRIDGE,
-            block.chainid
-        );
-        vm.etch(Predeploys.OPTIMISM_MINTABLE_ERC721_FACTORY, address(f).code);
-        factory = OptimismMintableERC721Factory(Predeploys.OPTIMISM_MINTABLE_ERC721_FACTORY);
-
+        // Label the L1 and L2 bridges.
         vm.label(address(L1Bridge), "L1ERC721Bridge");
-        vm.label(Predeploys.L2_ERC721_BRIDGE, "L2ERC721Bridge");
-        vm.label(Predeploys.OPTIMISM_MINTABLE_ERC721_FACTORY, "OptimismMintableERC721Factory");
+        vm.label(address(L2Bridge), "L2ERC721Bridge");
     }
 }
 

packages/contracts-bedrock/contracts/test/OptimismMintableERC721Factory.t.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import { ERC721Bridge_Initializer } from "./CommonTest.t.sol";
+import { LibRLP } from "./RLP.t.sol";
+import { OptimismMintableERC721 } from "../universal/OptimismMintableERC721.sol";
+import { OptimismMintableERC721Factory } from "../universal/OptimismMintableERC721Factory.sol";
+
+contract OptimismMintableERC721Factory_Test is ERC721Bridge_Initializer {
+    OptimismMintableERC721Factory internal factory;
+
+    event OptimismMintableERC721Created(
+        address indexed localToken,
+        address indexed remoteToken,
+        address deployer
+    );
+
+    function setUp() public override {
+        super.setUp();
+
+        // Set up the token pair.
+        factory = new OptimismMintableERC721Factory(address(L2Bridge), 1);
+
+        // Label the addresses for nice traces.
+        vm.label(address(factory), "OptimismMintableERC721Factory");
+    }
+
+    function test_constructor_succeeds() external {
+        assertEq(factory.bridge(), address(L2Bridge));
+        assertEq(factory.remoteChainId(), 1);
+        assertEq(factory.BRIDGE(), address(L2Bridge));
+        assertEq(factory.REMOTE_CHAIN_ID(), 1);
+    }
+
+    function test_constructor_zeroBridge_reverts() external {
+        vm.expectRevert("OptimismMintableERC721Factory: bridge cannot be address(0)");
+        new OptimismMintableERC721Factory(address(0), 1);
+    }
+
+    function test_constructor_zeroRemoteChainId_reverts() external {
+        vm.expectRevert("OptimismMintableERC721Factory: remote chain id cannot be zero");
+        new OptimismMintableERC721Factory(address(L2Bridge), 0);
+    }
+
+    function test_createOptimismMintableERC721_succeeds() external {
+        // Predict the address based on the factory address and nonce.
+        address predicted = LibRLP.computeAddress(address(factory), 1);
+
+        // Expect a token creation event.
+        vm.expectEmit(true, true, true, true);
+        emit OptimismMintableERC721Created(
+            predicted,
+            address(1234),
+            alice
+        );
+
+        // Create the token.
+        vm.prank(alice);
+        OptimismMintableERC721 created = OptimismMintableERC721(
+            factory.createOptimismMintableERC721(
+                address(1234),
+                "L2Token",
+                "L2T"
+            )
+        );
+
+        // Token address should be correct.
+        assertEq(address(created), predicted);
+
+        // Should be marked as created by the factory.
+        assertEq(factory.isOptimismMintableERC721(address(created)), true);
+
+        // Token should've been constructed correctly.
+        assertEq(created.name(), "L2Token");
+        assertEq(created.symbol(), "L2T");
+        assertEq(created.REMOTE_TOKEN(), address(1234));
+        assertEq(created.BRIDGE(), address(L2Bridge));
+        assertEq(created.REMOTE_CHAIN_ID(), 1);
+    }
+
+    function test_createOptimismMintableERC721_zeroRemoteToken_reverst() external {
+        // Try to create a token with a zero remote token address.
+        vm.expectRevert("OptimismMintableERC721Factory: L1 token address cannot be address(0)");
+        factory.createOptimismMintableERC721(
+            address(0),
+            "L2Token",
+            "L2T"
+        );
+    }
+}