@zoralabs/coins 0.7.1 → 1.0.0

package/test/DeploymentHooks.t.sol

@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {BaseTest} from "./utils/BaseTest.sol";
+import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IUniswapV3Pool} from "../src/interfaces/IUniswapV3Pool.sol";
+import {Coin} from "../src/Coin.sol";
+import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
+import {IHasAfterCoinDeploy} from "../src/hooks/deployment/BaseCoinDeployHook.sol";
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+
+// Create a fake hook that doesn't support the IHasAfterCoinDeploy interface
+contract FakeHookNoInterface {
+    function supportsInterface(bytes4) external pure returns (bool) {
+        return false; // Always returns false, doesn't support any interface
+    }
+}
+
+contract HooksTest is BaseTest {
+    address constant zora = 0x1111111111166b7FE7bd91427724B487980aFc69;
+
+    function _generateDefaultPoolConfig(address currency) internal pure returns (bytes memory) {
+        return
+            _generatePoolConfig(
+                CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+                currency,
+                DEFAULT_DISCOVERY_TICK_LOWER,
+                DEFAULT_DISCOVERY_TICK_UPPER,
+                DEFAULT_NUM_DISCOVERY_POSITIONS,
+                DEFAULT_DISCOVERY_SUPPLY_SHARE
+            );
+    }
+
+    function setUp() public override {
+        super.setUpWithBlockNumber(29585474);
+    }
+
+    function _deployWithHook(address hook, bytes memory hookData, address currency) internal returns (address, bytes memory) {
+        bytes memory poolConfig = _generateDefaultPoolConfig(currency);
+        return
+            factory.deployWithHook(
+                users.creator,
+                _getDefaultOwners(),
+                "https://test.com",
+                "Testcoin",
+                "TEST",
+                poolConfig,
+                users.platformReferrer,
+                hook,
+                hookData
+            );
+    }
+
+    function _encodeAfterCoinDeploy(address buyRecipient, bytes memory swapRouterCall) internal pure returns (bytes memory) {
+        return abi.encode(buyRecipient, swapRouterCall);
+    }
+
+    function _encodeExactInputSingle(address buyRecipient, ISwapRouter.ExactInputSingleParams memory params) internal pure returns (bytes memory) {
+        return _encodeAfterCoinDeploy(buyRecipient, abi.encodeWithSelector(ISwapRouter.exactInputSingle.selector, params));
+    }
+
+    function _encodeExactInput(address buyRecipient, ISwapRouter.ExactInputParams memory params) internal pure returns (bytes memory) {
+        return _encodeAfterCoinDeploy(buyRecipient, abi.encodeWithSelector(ISwapRouter.exactInput.selector, params));
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_withExactInputSingle(uint256 initialOrderSize) public {
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize < 1 ether);
+
+        vm.deal(users.creator, initialOrderSize);
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        bytes memory hookData = _encodeExactInputSingle(
+            users.creator,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(weth),
+                tokenOut: zora,
+                fee: 3000,
+                recipient: address(hook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        vm.prank(users.creator);
+        (address coinAddress, bytes memory hookDataOut) = factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        assertEq(coin.currency(), zora, "currency");
+        assertGt(amountCurrency, 0, "amountCurrency > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased > 0");
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize < 1 ether);
+
+        vm.deal(users.creator, initialOrderSize);
+
+        // lets try weth to usdc to zora
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        uint24 poolFee = 3000;
+
+        bytes memory hookData = _encodeExactInput(
+            users.creator,
+            ISwapRouter.ExactInputParams({
+                path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
+                recipient: address(hook),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0
+            })
+        );
+
+        vm.prank(users.creator);
+        (address coinAddress, bytes memory hookDataOut) = factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+
+        coin = Coin(payable(coinAddress));
+        pool = IUniswapV3Pool(coin.poolAddress());
+
+        (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
+
+        assertEq(coin.currency(), zora, "currency");
+        assertGt(amountCurrency, 0, "amountCurrency > 0");
+        assertGt(coinsPurchased, 0, "coinsPurchased > 0");
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased, "balanceOf creator");
+        assertGt(IERC20(zora).balanceOf(address(pool)), 0, "Pool ZORA balance");
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_revertsWhenBadCall() public {
+        vm.deal(users.creator, 0.0001 ether);
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        uint24 poolFee = 3000;
+
+        // exact output single is not supported
+        bytes memory hookData = _encodeAfterCoinDeploy(
+            users.creator,
+            abi.encodeWithSelector(
+                ISwapRouter.exactOutputSingle.selector,
+                ISwapRouter.ExactOutputParams({
+                    path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
+                    recipient: address(hook),
+                    amountOut: 0.0001 ether,
+                    amountInMaximum: 0
+                })
+            )
+        );
+
+        vm.prank(users.creator);
+        vm.expectRevert(BuySupplyWithSwapRouterHook.InvalidSwapRouterCall.selector);
+        factory.deployWithHook{value: 0.0001 ether}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+    }
+
+    function test_buySupplyWithEthUsingV3Hook_revertsWhenHookNotRecipient() public {
+        uint256 initialOrderSize = 0.0001 ether;
+        vm.deal(users.creator, initialOrderSize);
+
+        BuySupplyWithSwapRouterHook hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter));
+
+        bytes memory hookData = _encodeExactInputSingle(
+            users.creator,
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(weth),
+                tokenOut: zora,
+                fee: 3000,
+                recipient: address(users.creator),
+                amountIn: initialOrderSize,
+                amountOutMinimum: 0,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        vm.prank(users.creator);
+        vm.expectRevert(BuySupplyWithSwapRouterHook.Erc20NotReceived.selector);
+        factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(hook),
+            hookData
+        );
+    }
+
+    function test_deployWithHook_revertsWhenEthAndNoHook() public {
+        uint256 initialOrderSize = 0.0001 ether;
+        vm.deal(users.creator, initialOrderSize);
+
+        vm.prank(users.creator);
+        vm.expectRevert(IZoraFactory.EthTransferInvalid.selector);
+        factory.deployWithHook{value: initialOrderSize}(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            _generateDefaultPoolConfig(zora),
+            users.platformReferrer,
+            address(0),
+            ""
+        );
+    }
+
+    function test_invalidHookReverts() public {
+        // Deploy a fake hook that doesn't support the IHasAfterCoinDeploy interface
+        FakeHookNoInterface fakeHook = new FakeHookNoInterface();
+
+        bytes memory hookData = "";
+
+        // Expect the transaction to revert with InvalidHook error
+        vm.expectRevert(IZoraFactory.InvalidHook.selector);
+        vm.prank(users.creator);
+        _deployWithHook(address(fakeHook), hookData, zora);
+    }
+
+    function test_noHookWorksAsNormal() public {
+        // Expect the transaction to revert with InvalidHook error
+        vm.prank(users.creator);
+        _deployWithHook(address(0), bytes(""), zora);
+    }
+}

package/test/Factory.t.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.13;
 
 import "./utils/BaseTest.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
 
 contract FactoryTest is BaseTest {
     function setUp() public override {
@@ -9,8 +10,9 @@ contract FactoryTest is BaseTest {
     }
 
     function test_constructor() public view {
-        assertEq(factory.coinImpl(), address(coinImpl));
-        assertEq(factory.owner(), users.factoryOwner);
+        assertEq(ZoraFactoryImpl(address(factory)).coinImpl(), address(coinV3Impl));
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
+        assertEq(ZoraFactoryImpl(address(factory)).coinV4Impl(), address(coinV4Impl));
     }
 
     function test_deploy_no_eth() public {
@@ -23,9 +25,8 @@ contract FactoryTest is BaseTest {
             "https://test2.com",
             "Test2 Token",
             "TEST2",
+            _generatePoolConfig(address(weth)),
             users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
             0
         );
         coin = Coin(payable(coinAddress));
@@ -58,7 +59,7 @@ contract FactoryTest is BaseTest {
     }
 
     function test_deploy_with_eth(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 10 ether);
 
         address[] memory owners = new address[](1);
@@ -72,9 +73,8 @@ contract FactoryTest is BaseTest {
             "https://test2.com",
             "Test2 Token",
             "TEST2",
+            _generatePoolConfig(address(weth)),
             users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
             initialOrderSize
         );
         coin = Coin(payable(coinAddress));
@@ -97,7 +97,7 @@ contract FactoryTest is BaseTest {
     }
 
     function test_deploy_with_weth(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > MIN_ORDER_SIZE);
+        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 10 ether);
 
         address[] memory owners = new address[](1);
@@ -118,9 +118,8 @@ contract FactoryTest is BaseTest {
             "https://test2.com",
             "Test2 Token",
             "TEST2",
+            _generatePoolConfig(address(weth)),
             users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
             initialOrderSize
         );
     }
@@ -138,9 +137,8 @@ contract FactoryTest is BaseTest {
             "https://test2.com",
             "Test2 Token",
             "TEST2",
+            _generatePoolConfig(address(weth)),
             users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
             orderSize
         );
         coin = Coin(payable(coinAddress));
@@ -159,9 +157,8 @@ contract FactoryTest is BaseTest {
             "https://testcoinusdcpair.com",
             "Testcoinusdcpair",
             "TESTCOINUSDCPAIR",
+            _generatePoolConfig(USDC_ADDRESS),
             users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
             0
         );
         coin = Coin(payable(coinAddress));
@@ -192,9 +189,8 @@ contract FactoryTest is BaseTest {
             "https://testcoinusdcpair.com",
             "Testcoinusdcpair",
             "TESTCOINUSDCPAIR",
+            _generatePoolConfig(USDC_ADDRESS),
             users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
             orderSize
         );
         coin = Coin(payable(coinAddress));
@@ -203,7 +199,7 @@ contract FactoryTest is BaseTest {
         vm.label(address(pool), "POOL");
 
         assertEq(coin.currency(), USDC_ADDRESS, "currency");
-        assertEq(coin.balanceOf(users.creator), CREATOR_LAUNCH_REWARD + coinsPurchased);
+        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased);
     }
 
     function test_deploy_with_usdc_revert_payout_recipient_zero() public {
@@ -217,9 +213,8 @@ contract FactoryTest is BaseTest {
             "https://testcoinusdcpair.com",
             "Testcoinusdcpair",
             "TESTCOINUSDCPAIR",
+            _generatePoolConfig(USDC_ADDRESS),
             users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
             0
         );
     }
@@ -234,9 +229,8 @@ contract FactoryTest is BaseTest {
             "https://testcoinusdcpair.com",
             "Testcoinusdcpair",
             "TESTCOINUSDCPAIR",
+            _generatePoolConfig(USDC_ADDRESS),
             users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
             0
         );
     }
@@ -251,9 +245,8 @@ contract FactoryTest is BaseTest {
             "https://testcoinusdcpair.com",
             "Testcoinusdcpair",
             "TESTCOINUSDCPAIR",
+            _generatePoolConfig(USDC_ADDRESS),
             address(0),
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
             0
         );
 
@@ -262,24 +255,6 @@ contract FactoryTest is BaseTest {
         assertEq(coin.platformReferrer(), coin.protocolRewardRecipient(), "platformReferrer");
     }
 
-    function test_revert_deploy_with_invalid_currency_tick() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.expectRevert(abi.encodeWithSelector(ICoin.InvalidWethLowerTick.selector));
-        factory.deploy(
-            users.creator,
-            owners,
-            "https://testcoin.com",
-            "Testcoin",
-            "TESTCOIN",
-            users.platformReferrer,
-            address(0),
-            MarketConstants.LP_TICK_LOWER_WETH + 1,
-            0
-        );
-    }
-
     function test_deploy_with_usdc_revert_invalid_eth_transfer() public {
         address[] memory owners = new address[](1);
         owners[0] = users.creator;
@@ -297,9 +272,8 @@ contract FactoryTest is BaseTest {
             "https://testcoinusdcpair.com",
             "Testcoinusdcpair",
             "TESTCOINUSDCPAIR",
+            _generatePoolConfig(USDC_ADDRESS),
             users.platformReferrer,
-            USDC_ADDRESS,
-            USDC_TICK_LOWER,
             0
         );
     }
@@ -314,9 +288,8 @@ contract FactoryTest is BaseTest {
             "https://test.com",
             "Test Token",
             "TEST",
+            _generatePoolConfig(address(weth)),
             users.platformReferrer,
-            address(weth),
-            MarketConstants.LP_TICK_LOWER_WETH,
             0
         );
         coin = Coin(payable(coinAddress));
@@ -325,10 +298,10 @@ contract FactoryTest is BaseTest {
     }
 
     function test_upgrade() public {
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinImpl));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV3Impl), address(coinV4Impl));
 
         vm.prank(users.factoryOwner);
-        factory.upgradeToAndCall(address(newImpl), "");
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
 
         assertEq(factory.implementation(), address(newImpl), "implementation");
     }
@@ -342,14 +315,75 @@ contract FactoryTest is BaseTest {
 
         vm.prank(users.factoryOwner);
         vm.expectRevert(abi.encodeWithSelector(ERC1967Utils.ERC1967InvalidImplementation.selector, address(newImpl)));
-        factory.upgradeToAndCall(address(newImpl), "");
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
     }
 
     function test_revert_invalid_owner() public {
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinImpl));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV3Impl), address(coinV4Impl));
 
         vm.prank(users.creator);
         vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, users.creator));
-        factory.upgradeToAndCall(address(newImpl), "");
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
+    }
+
+    function test_coinAddress_canBePredicted(
+        bool msgSenderChanged,
+        bool saltChanged,
+        bool poolConfigChanged,
+        bool platformReferrerChanged,
+        bool nameChanged,
+        bool symbolChanged
+    ) public {
+        address[] memory owners = new address[](1);
+        owners[0] = users.creator;
+
+        address payoutRecipient = users.creator;
+
+        bytes32 salt = keccak256(abi.encode(bytes("randomSalt")));
+
+        address msgSender = makeAddr("msgSender");
+
+        string memory uri = "https://test.com";
+        string memory name = "Testcoin";
+        string memory symbol = "TEST";
+
+        address platformReferrer = users.platformReferrer;
+
+        bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(weth));
+        bytes memory poolConfigForGettingAddress = poolConfigChanged ? CoinConfigurationVersions.defaultDopplerUniV3(address(weth)) : poolConfig;
+
+        address expectedCoinAddress = factory.coinAddress(msgSender, name, symbol, poolConfigForGettingAddress, platformReferrer, salt);
+
+        if (msgSenderChanged) {
+            msgSender = makeAddr("msgSender2");
+        }
+
+        if (saltChanged) {
+            salt = keccak256(abi.encode(bytes("randomSalt2")));
+        }
+
+        if (platformReferrerChanged) {
+            platformReferrer = makeAddr("platformReferrer2");
+        }
+
+        if (nameChanged) {
+            name = "Testcoin2";
+        }
+
+        if (symbolChanged) {
+            symbol = "TEST2";
+        }
+
+        // now deploy the coin
+        vm.prank(msgSender);
+        (address coinAddress, ) = factory.deploy(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, address(0), bytes(""), salt);
+
+        bool addressShouldMismatch = msgSenderChanged || saltChanged || poolConfigChanged || platformReferrerChanged || nameChanged || symbolChanged;
+
+        if (addressShouldMismatch) {
+            assertNotEq(coinAddress, expectedCoinAddress, "coinAddress should mismatch");
+        } else {
+            assertEq(coinAddress, expectedCoinAddress, "coinAddress should match");
+        }
     }
 }

package/test/MultiOwnable.t.sol

@@ -135,22 +135,25 @@ contract MultiOwnableTest is BaseTest {
 
     function test_revert_init_with_zero_owners() public {
         address[] memory emptyOwners = new address[](0);
+        bytes memory poolConfig_ = _generatePoolConfig(address(weth));
         vm.expectRevert(MultiOwnable.OneOwnerRequired.selector);
-        factory.deploy(users.creator, emptyOwners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(0), 0, 0);
+        factory.deploy(users.creator, emptyOwners, "https://test.com", "Test Token", "TEST", poolConfig_, users.platformReferrer, 0);
     }
 
     function test_revert_init_with_zero_address() public {
         address[] memory owners = new address[](1);
         owners[0] = address(0);
+        bytes memory poolConfig_ = _generatePoolConfig(address(weth));
         vm.expectRevert(MultiOwnable.OwnerCannotBeAddressZero.selector);
-        factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(0), 0, 0);
+        factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", poolConfig_, users.platformReferrer, 0);
     }
 
     function test_revert_init_with_duplicate_owner() public {
         address[] memory owners = new address[](2);
         owners[0] = users.creator;
         owners[1] = users.creator;
+        bytes memory poolConfig_ = _generatePoolConfig(address(weth));
         vm.expectRevert(MultiOwnable.AlreadyOwner.selector);
-        factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", users.platformReferrer, address(0), 0, 0);
+        factory.deploy(users.creator, owners, "https://test.com", "Test Token", "TEST", poolConfig_, users.platformReferrer, 0);
     }
 }

package/test/Upgrades.t.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+import {Test} from "forge-std/Test.sol";
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
+import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
+import {BaseTest} from "./utils/BaseTest.sol";
+
+contract BadImpl {
+    function contractName() public pure returns (string memory) {
+        return "BadImpl";
+    }
+}
+
+contract UpgradesTest is BaseTest {
+    ZoraFactoryImpl public factoryProxy;
+
+    function test_canUpgradeFromVersionWithoutContractName() public {
+        // this test that we can upgrade from the current version, which doesn't have a contract name
+        vm.createSelectFork("base", 29675508);
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(factoryProxy.coinImpl(), address(coinV4Impl));
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl), "");
+
+        assertEq(factoryProxy.implementation(), address(newImpl));
+    }
+
+    function test_cannotUpgradeToMismatchedContractName() public {
+        // this test that we cannot upgrade to a contract with a mismatched contract name
+        // once we have upgraded to the version that checks the contract name when upgrading
+        vm.createSelectFork("base", 29675508);
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(factoryProxy.coinImpl(), address(coinV4Impl));
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl), "");
+
+        BadImpl badImpl = new BadImpl();
+
+        vm.prank(factoryProxy.owner());
+        vm.expectRevert(abi.encodeWithSelector(IZoraFactory.UpgradeToMismatchedContractName.selector, "ZoraCoinFactory", "BadImpl"));
+        factoryProxy.upgradeToAndCall(address(badImpl), "");
+    }
+
+    function test_canUpgradeToSameContractName() public {
+        // this test that we can upgrade to the same contract name, when we have already upgraded to a version that has a contract name
+        vm.createSelectFork("base", 29675508);
+
+        factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
+
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(factoryProxy.coinImpl(), address(coinV4Impl));
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl), "");
+
+        ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(factoryProxy.coinImpl(), factoryProxy.coinV4Impl());
+
+        vm.prank(factoryProxy.owner());
+        factoryProxy.upgradeToAndCall(address(newImpl2), "");
+
+        assertEq(factoryProxy.implementation(), address(newImpl2));
+    }
+}

package/test/mocks/MockERC20.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+}