@zoralabs/coins 1.1.2 → 2.1.0

package/test/CoinUniV4.t.sol

@@ -29,7 +29,7 @@ import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {PoolStateReader} from "../src/libs/PoolStateReader.sol";
 import {CustomRevert} from "@uniswap/v4-core/src/libraries/CustomRevert.sol";
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
-import {ICoinV4, IHasSwapPath, PathKey} from "../src/interfaces/ICoinV4.sol";
+import {ICoin, IHasSwapPath, PathKey} from "../src/interfaces/ICoin.sol";
 import {IDeployedCoinVersionLookup} from "../src/interfaces/IDeployedCoinVersionLookup.sol";
 
 contract CoinUniV4Test is BaseTest {
@@ -63,7 +63,7 @@ contract CoinUniV4Test is BaseTest {
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        feeState = FeeEstimatorHook(address(contentCoinHook)).getFeeState();
+        feeState = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState();
 
         vm.revertToState(snapshot);
     }
@@ -80,8 +80,8 @@ contract CoinUniV4Test is BaseTest {
         uint256 deadline = block.timestamp + 20;
         router.execute(commands, inputs, deadline);
 
-        delta = FeeEstimatorHook(address(contentCoinHook)).getFeeState().lastDelta;
-        swapParams = FeeEstimatorHook(address(contentCoinHook)).getFeeState().lastSwapParams;
+        delta = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastDelta;
+        swapParams = FeeEstimatorHook(payable(address(contentCoinHook))).getFeeState().lastSwapParams;
 
         sqrtPriceX96 = PoolStateReader.getSqrtPriceX96(coinV4.getPoolKey(), poolManager);
 
@@ -90,7 +90,7 @@ contract CoinUniV4Test is BaseTest {
 
     function test_setupZeroAddressForPoolManager() public {
         vm.expectRevert(ICoin.AddressZero.selector);
-        new CoinV4({
+        new ContentCoin({
             protocolRewardRecipient_: address(0x1234),
             protocolRewards_: address(0x1234),
             poolManager_: IPoolManager(address(0)),
@@ -100,7 +100,7 @@ contract CoinUniV4Test is BaseTest {
 
     // function test_setupZeroAddressForHooks() public {
     //     vm.expectRevert(ICoin.AddressZero.selector);
-    //     new CoinV4({
+    //     new ContentCoin({
     //         protocolRewardRecipient_: address(0x1234),
     //         protocolRewards_: address(0x1234),
     //         poolManager_: IPoolManager(address(0x1234)),
@@ -293,6 +293,62 @@ contract CoinUniV4Test is BaseTest {
         assertApproxEqAbs(mockERC20A.balanceOf(coinV4.protocolRewardRecipient()), totalRewards.protocol, 10, "protocol reward currency");
     }
 
+    function test_distributesMarketRewardsInEth() public {
+        uint64 amountIn = 0.1 ether;
+
+        // Use address(0) as currency to price the coin in ETH
+        address currency = address(0);
+        bytes32 salt = keccak256(abi.encodePacked("eth-rewards-test"));
+        _deployV4Coin(currency, address(0), salt);
+
+        address trader = makeAddr("trader");
+
+        // Give trader ETH
+        vm.deal(trader, amountIn);
+
+        // Record initial ETH balance of payout recipient
+        uint256 initialPayoutBalance = coinV4.payoutRecipient().balance;
+
+        // Swap ETH for coin
+        _swapSomeCurrencyForCoin(coinV4, currency, amountIn, trader);
+
+        // Verify that rewards were paid out in ETH
+        assertGt(coinV4.payoutRecipient().balance, initialPayoutBalance, "backing reward should be paid in ETH");
+    }
+
+    function test_canSwapEthForCoin(uint128 amountIn) public {
+        vm.assume(amountIn > 0.00001 ether);
+        vm.assume(amountIn < 1 ether);
+
+        // Use address(0) as currency to price the coin in ETH
+        address currency = address(0);
+        bytes32 salt = keccak256(abi.encodePacked("eth-coin-test"));
+        _deployV4Coin(currency, address(0), salt);
+
+        address trader = makeAddr("trader");
+
+        // Give trader ETH
+        vm.deal(trader, amountIn);
+
+        uint256 initialEthBalance = trader.balance;
+
+        // Swap ETH for coin
+        _swapSomeCurrencyForCoin(coinV4, currency, amountIn, trader);
+
+        // Verify the swap worked
+        assertEq(trader.balance, initialEthBalance - amountIn, "trader should have spent ETH");
+        assertGt(coinV4.balanceOf(trader), 0, "trader should have received coin");
+
+        // Now swap some coin back for ETH
+        uint128 coinBalance = uint128(coinV4.balanceOf(trader));
+
+        _swapSomeCoinForCurrency(coinV4, currency, coinBalance, trader);
+
+        // Verify the reverse swap worked
+        assertEq(coinV4.balanceOf(trader), 0, "trader should have no coins left");
+        assertGt(trader.balance, 0, "trader should have received ETH back");
+    }
+
     function test_swap_emitsCoinMarketRewardsV4(uint64 amountIn) public {
         vm.assume(amountIn > 0.00001 ether);
         address currency = address(mockERC20A);
@@ -649,9 +705,9 @@ contract CoinUniV4Test is BaseTest {
 
     function test_getSwapPath_whenBackingCurrencyProvidesPath() public {
         address zora = address(mockERC20A);
-        ICoinV4 backingCoin = _deployV4Coin(zora);
+        ICoin backingCoin = _deployV4Coin(zora);
         // now create a final coin paired with the backing coin
-        ICoinV4 contentCoin = _deployV4Coin(address(backingCoin));
+        ICoin contentCoin = _deployV4Coin(address(backingCoin));
 
         PathKey[] memory path = contentCoin.getPayoutSwapPath(IDeployedCoinVersionLookup(address(factory))).path;
 
@@ -690,9 +746,9 @@ contract CoinUniV4Test is BaseTest {
         mockERC20A.mint(address(poolManager), 10000000000000000 ether);
 
         // backing coin is a mock coin that is paired with zora
-        ICoinV4 backingCoin = _deployV4Coin(zora);
+        ICoin backingCoin = _deployV4Coin(zora);
         // now create a final coin paired with the backing coin
-        ICoinV4 contentCoin = _deployV4Coin(address(backingCoin));
+        ICoin contentCoin = _deployV4Coin(address(backingCoin));
 
         vm.assume(amountIn > 0.000000000001 ether);
         vm.assume(amountIn < 10000000000000000 ether);

package/test/DeploymentHooks.t.sol

@@ -5,7 +5,6 @@ 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";
@@ -13,6 +12,7 @@ import {IHasAfterCoinDeploy} from "../src/hooks/deployment/BaseCoinDeployHook.so
 import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {ContentCoin} from "../src/ContentCoin.sol";
 
 // Create a fake hook that doesn't support the IHasAfterCoinDeploy interface
 contract FakeHookNoInterface {
@@ -26,15 +26,7 @@ contract HooksTest is BaseTest {
     BuySupplyWithSwapRouterHook hook;
 
     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
-            );
+        return _generatePoolConfig(currency);
     }
 
     function setUp() public override {
@@ -71,50 +63,6 @@ contract HooksTest is BaseTest {
         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);
-
-        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_buySupplyWithEthUsingV4Hook_withExactInputMultiHop(uint256 initialOrderSize) public {
         vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
         vm.assume(initialOrderSize < 1 ether);
@@ -150,62 +98,17 @@ contract HooksTest is BaseTest {
             hookData
         );
 
-        coin = Coin(payable(coinAddress));
+        coinV4 = ContentCoin(payable(coinAddress));
 
         (uint256 amountCurrency, uint256 coinsPurchased) = abi.decode(hookDataOut, (uint256, uint256));
 
-        assertEq(coin.currency(), zora, "currency");
+        assertEq(coinV4.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");
+        assertEq(coinV4.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
-
-        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);
 

package/test/Factory.t.sol

@@ -3,6 +3,8 @@ pragma solidity ^0.8.13;
 
 import "./utils/BaseTest.sol";
 import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
+import {IZoraFactory} from "../src/interfaces/IZoraFactory.sol";
 
 contract FactoryTest is BaseTest {
     function setUp() public override {
@@ -11,14 +13,7 @@ contract FactoryTest is BaseTest {
 
     function test_factory_constructor_and_proxy_setup() public {
         // Impl constructor test
-        ZoraFactoryImpl impl = new ZoraFactoryImpl(
-            address(coinV3Impl),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
-        assertEq(ZoraFactoryImpl(address(factory)).coinImpl(), address(coinV3Impl));
+        ZoraFactoryImpl impl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
         assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
         assertEq(ZoraFactoryImpl(address(factory)).coinV4Impl(), address(coinV4Impl));
 
@@ -29,296 +24,49 @@ contract FactoryTest is BaseTest {
         assertEq(ZoraFactoryImpl(address(factory)).owner(), initialOwner);
     }
 
-    function test_deploy_no_eth() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://test2.com",
-            "Test2 Token",
-            "TEST2",
-            _generatePoolConfig(address(weth)),
-            users.platformReferrer,
-            0
-        );
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-
-        uint160 sqrtPriceX96 = pool.slot0().sqrtPriceX96;
-        uint256 poolCoinBalance = coin.balanceOf(address(pool));
-        uint256 poolEthBalance = weth.balanceOf(address(pool));
-
-        console.log("POOL_TOKEN_0: ", pool.token0());
-        console.log("POOL_TOKEN_1: ", pool.token1());
-        console.log("POOL_SQRT_PRICE_X96: ", sqrtPriceX96);
-        console.log("");
-        console.log("POOL_COIN_BALANCE: ", poolCoinBalance);
-        console.log("POOL_ETH_BALANCE: ", poolEthBalance);
-        console.log("");
-
-        assertEq(coin.payoutRecipient(), users.creator, "payoutRecipient");
-        assertEq(coin.protocolRewardRecipient(), users.feeRecipient, "protocolRewardRecipient");
-        assertEq(coin.platformReferrer(), users.platformReferrer, "platformReferrer");
-        assertEq(coin.tokenURI(), "https://test2.com", "tokenURI");
-        assertEq(coin.name(), "Test2 Token", "name");
-        assertEq(coin.symbol(), "TEST2", "symbol");
-        assertEq(coin.currency(), address(weth), "currency");
-        assertEq(coin.totalSupply(), 1_000_000_000e18, "totalSupply");
-        assertEq(coin.balanceOf(users.creator), 10_000_000e18, "balanceOf creator");
-        assertGt(coin.balanceOf(coin.poolAddress()), 989_999_999e18, "balanceOf pool");
-    }
-
-    function test_deploy_with_eth(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
-        vm.assume(initialOrderSize < 10 ether);
-
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.deal(users.creator, initialOrderSize);
-        vm.prank(users.creator);
-        (address coinAddress, ) = factory.deploy{value: initialOrderSize}(
-            users.creator,
-            owners,
-            "https://test2.com",
-            "Test2 Token",
-            "TEST2",
-            _generatePoolConfig(address(weth)),
-            users.platformReferrer,
-            initialOrderSize
-        );
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-
-        uint160 sqrtPriceX96 = pool.slot0().sqrtPriceX96;
-        uint256 poolCoinBalance = coin.balanceOf(address(pool));
-        uint256 poolEthBalance = weth.balanceOf(address(pool));
-
-        console.log("POOL_TOKEN_0: ", pool.token0());
-        console.log("POOL_TOKEN_1: ", pool.token1());
-        console.log("POOL_SQRT_PRICE_X96: ", sqrtPriceX96);
-        console.log("");
-        console.log("POOL_COIN_BALANCE: ", poolCoinBalance);
-        console.log("POOL_ETH_BALANCE: ", poolEthBalance);
-        console.log("");
-        console.log("BUYER_COIN_BALANCE ", coin.balanceOf(users.creator) - 10_000_000e18);
-    }
-
-    function test_deploy_with_weth(uint256 initialOrderSize) public {
-        vm.assume(initialOrderSize > CoinConstants.MIN_ORDER_SIZE);
-        vm.assume(initialOrderSize < 10 ether);
-
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.deal(users.creator, initialOrderSize);
-
-        vm.startPrank(users.creator);
-        weth.deposit{value: initialOrderSize}();
-
-        weth.approve(address(factory), type(uint256).max);
-
-        // Expect this to revert because WETH needs to be sent with msg.value.
-        vm.expectRevert();
-        factory.deploy(
-            users.creator,
-            owners,
-            "https://test2.com",
-            "Test2 Token",
-            "TEST2",
-            _generatePoolConfig(address(weth)),
-            users.platformReferrer,
-            initialOrderSize
-        );
-    }
-
-    function test_deploy_with_one_eth() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        uint256 orderSize = 1 ether;
-        vm.deal(users.creator, orderSize);
-
-        (address coinAddress, ) = factory.deploy{value: orderSize}(
-            users.creator,
-            owners,
-            "https://test2.com",
-            "Test2 Token",
-            "TEST2",
-            _generatePoolConfig(address(weth)),
-            users.platformReferrer,
-            orderSize
-        );
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-    }
-
-    function test_deploy_with_usdc() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            _generatePoolConfig(USDC_ADDRESS),
-            users.platformReferrer,
-            0
-        );
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-
-        assertEq(coin.currency(), USDC_ADDRESS, "currency");
-        assertEq(coin.payoutRecipient(), users.creator, "payoutRecipient");
-    }
-
-    function test_deploy_with_usdc_order() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        uint256 orderSize = dealUSDC(users.creator, 100);
+    function test_ownable2Step() public {
+        // old current impl
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
 
-        vm.prank(users.creator);
-        usdc.approve(address(factory), orderSize);
+        // 1st ensure owner slot is set at expected address
 
-        assertEq(usdc.balanceOf(users.creator), orderSize);
-        assertEq(usdc.allowance(users.creator, address(factory)), orderSize);
+        bytes32 ownableSlot = hex"9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300";
+        bytes32 ownable2StepSlot = hex"237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00";
 
-        vm.prank(users.creator);
-        (address coinAddress, uint256 coinsPurchased) = factory.deploy(
-            users.creator,
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            _generatePoolConfig(USDC_ADDRESS),
-            users.platformReferrer,
-            orderSize
-        );
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
+        address ownerAddress = address(uint160(uint256(vm.load(address(factory), ownableSlot))));
+        assertEq(ownerAddress, users.factoryOwner);
 
-        assertEq(coin.currency(), USDC_ADDRESS, "currency");
-        assertEq(coin.balanceOf(users.creator), CoinConstants.CREATOR_LAUNCH_REWARD + coinsPurchased);
-    }
+        assertEq(ZoraFactoryImpl(address(factory)).pendingOwner(), address(0));
 
-    function test_deploy_with_usdc_revert_payout_recipient_zero() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        vm.expectRevert(abi.encodeWithSelector(ICoin.AddressZero.selector));
-        factory.deploy(
-            address(0),
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            _generatePoolConfig(USDC_ADDRESS),
-            users.platformReferrer,
-            0
+        address newFactoryImpl = address(
+            new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook))
         );
-    }
 
-    function test_deploy_with_usdc_revert_one_owner_required() public {
-        address[] memory owners = new address[](0);
-
-        vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OneOwnerRequired.selector));
-        factory.deploy(
-            users.creator,
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            _generatePoolConfig(USDC_ADDRESS),
-            users.platformReferrer,
-            0
-        );
-    }
-
-    function test_deploy_with_usdc_platform_referrer_zero() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            _generatePoolConfig(USDC_ADDRESS),
-            address(0),
-            0
-        );
-
-        coin = Coin(payable(coinAddress));
-
-        assertEq(coin.platformReferrer(), coin.protocolRewardRecipient(), "platformReferrer");
-    }
-
-    function test_deploy_with_usdc_revert_invalid_eth_transfer() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
-
-        dealUSDC(users.creator, 1);
+        // Upgrade to current / new impl
+        vm.prank(users.factoryOwner);
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(newFactoryImpl, "");
 
-        vm.deal(users.creator, 1e6);
+        // 2nd ensure owner is read from correct slot
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
 
-        vm.prank(users.creator);
-        vm.expectRevert(abi.encodeWithSelector(ICoin.EthTransferInvalid.selector));
-
-        factory.deploy{value: 1e6}(
-            users.creator,
-            owners,
-            "https://testcoinusdcpair.com",
-            "Testcoinusdcpair",
-            "TESTCOINUSDCPAIR",
-            _generatePoolConfig(USDC_ADDRESS),
-            users.platformReferrer,
-            0
-        );
-    }
+        address newOwner = makeAddr("newOwner");
 
-    function test_deploy_without_initial_order() public {
-        address[] memory owners = new address[](1);
-        owners[0] = users.creator;
+        // 3rd ensure pending owner is set correctly
+        vm.prank(users.factoryOwner);
+        ZoraFactoryImpl(address(factory)).transferOwnership(newOwner);
+        assertEq(ZoraFactoryImpl(address(factory)).pendingOwner(), newOwner);
 
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            owners,
-            "https://test.com",
-            "Test Token",
-            "TEST",
-            _generatePoolConfig(address(weth)),
-            users.platformReferrer,
-            0
-        );
-        coin = Coin(payable(coinAddress));
+        address ownerAddress2Step = address(uint160(uint256(vm.load(address(factory), ownable2StepSlot))));
+        assertEq(ownerAddress2Step, newOwner);
 
-        assertEq(coin.balanceOf(users.creator), 10_000_000e18, "Should only have initial creator allocation");
+        // 4th ensure owner is set correctly
+        vm.prank(newOwner);
+        ZoraFactoryImpl(address(factory)).acceptOwnership();
+        assertEq(ZoraFactoryImpl(address(factory)).owner(), newOwner);
     }
 
     function test_upgrade() public {
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            address(coinV3Impl),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(users.factoryOwner);
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
@@ -339,13 +87,7 @@ contract FactoryTest is BaseTest {
     }
 
     function test_revert_invalid_owner() public {
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            address(coinV3Impl),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(users.creator);
         vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, users.creator));
@@ -376,7 +118,7 @@ contract FactoryTest is BaseTest {
         address platformReferrer = users.platformReferrer;
 
         bytes memory poolConfig = CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(weth));
-        bytes memory poolConfigForGettingAddress = poolConfigChanged ? CoinConfigurationVersions.defaultDopplerUniV3(address(weth)) : poolConfig;
+        bytes memory poolConfigForGettingAddress = poolConfigChanged ? CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(address(0)) : poolConfig;
 
         address expectedCoinAddress = factory.coinAddress(msgSender, name, symbol, poolConfigForGettingAddress, platformReferrer, salt);
 
@@ -412,4 +154,20 @@ contract FactoryTest is BaseTest {
             assertEq(coinAddress, expectedCoinAddress, "coinAddress should match");
         }
     }
+
+    function test_upgrade_with_mismatched_contract_name() public {
+        // Create a mock implementation with different contract name
+        MockBadFactory badImpl = new MockBadFactory();
+
+        vm.prank(users.factoryOwner);
+        vm.expectRevert(abi.encodeWithSelector(IZoraFactory.UpgradeToMismatchedContractName.selector, "ZoraCoinFactory", "BadFactory"));
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(badImpl), "");
+    }
+}
+
+// Mock contracts for testing
+contract MockBadFactory is IHasContractName {
+    function contractName() external pure returns (string memory) {
+        return "BadFactory";
+    }
 }