@zoralabs/coins 2.0.0 → 2.1.1

package/test/LiquidityMigration.t.sol

@@ -13,9 +13,11 @@ import {LpPosition} from "../src/types/LpPosition.sol";
 import {V4Liquidity} from "../src/libs/V4Liquidity.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IZoraV4CoinHook} from "../src/interfaces/IZoraV4CoinHook.sol";
-import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {CoinCommon} from "../src/libs/CoinCommon.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
 
 contract LiquidityMigrationReceiver is IUpgradeableDestinationV4Hook, IERC165 {
     function initializeFromMigration(
@@ -175,7 +177,7 @@ contract LiquidityMigrationTest is BaseTest {
         // migrate the liquidity
         vm.prank(users.creator);
         vm.expectEmit(true, true, true, true);
-        emit ICoinV4.LiquidityMigrated(poolKey, fromPoolKeyHash, newPoolKey, toPoolKeyHash);
+        emit ICoin.LiquidityMigrated(poolKey, fromPoolKeyHash, newPoolKey, toPoolKeyHash);
         coinV4.migrateLiquidity(address(newHook), "");
     }
 
@@ -230,4 +232,160 @@ contract LiquidityMigrationTest is BaseTest {
         vm.expectRevert(abi.encodeWithSelector(IZoraV4CoinHook.OnlyCoin.selector, users.creator, address(coinV4)));
         IUpgradeableV4Hook(originalHook).migrateLiquidity(address(newHook), poolKey, "");
     }
+
+    // Hook Upgrade Gate Tests
+    function test_hookUpgradeGate_removeUpgradePath() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        // First register the upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // Verify it's registered
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+
+        // Remove the upgrade path
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRemoved(baseImpl, upgradeImpl);
+        hookUpgradeGate.removeUpgradePath(baseImpl, upgradeImpl);
+
+        // Verify it's removed
+        assertFalse(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_removeUpgradePath_onlyOwner() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+        address nonOwner = makeAddr("nonOwner");
+
+        // Try to remove upgrade path as non-owner
+        vm.prank(nonOwner);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        hookUpgradeGate.removeUpgradePath(baseImpl, upgradeImpl);
+    }
+
+    function test_hookUpgradeGate_registerUpgradePath_onlyOwner() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+        address nonOwner = makeAddr("nonOwner");
+
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+
+        // Try to register upgrade path as non-owner
+        vm.prank(nonOwner);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.OwnableUnauthorizedAccount.selector, nonOwner));
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+    }
+
+    function test_hookUpgradeGate_registerMultipleUpgradePaths() public {
+        address baseImpl1 = makeAddr("baseImpl1");
+        address baseImpl2 = makeAddr("baseImpl2");
+        address baseImpl3 = makeAddr("baseImpl3");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        address[] memory baseImpls = new address[](3);
+        baseImpls[0] = baseImpl1;
+        baseImpls[1] = baseImpl2;
+        baseImpls[2] = baseImpl3;
+
+        // Register multiple upgrade paths at once
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl1, upgradeImpl);
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl2, upgradeImpl);
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl3, upgradeImpl);
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // Verify all paths are registered
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl1, upgradeImpl));
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl2, upgradeImpl));
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl3, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_registerEmptyArray() public {
+        address upgradeImpl = makeAddr("upgradeImpl");
+        address[] memory baseImpls = new address[](0);
+
+        // Register with empty array - should succeed but do nothing
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // No events should be emitted, no state changes
+    }
+
+    function test_hookUpgradeGate_removeNonexistentUpgradePath() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        // Try to remove a path that was never registered
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRemoved(baseImpl, upgradeImpl);
+        hookUpgradeGate.removeUpgradePath(baseImpl, upgradeImpl);
+
+        // Should still be false (was already false)
+        assertFalse(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_registerSamePathTwice() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+
+        // Register once
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+
+        // Register again - should succeed and overwrite (true -> true)
+        vm.prank(hookUpgradeGate.owner());
+        vm.expectEmit(true, true, false, false);
+        emit IHooksUpgradeGate.UpgradeRegistered(baseImpl, upgradeImpl);
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
+
+    function test_hookUpgradeGate_zeroAddressHandling() public {
+        address[] memory baseImpls = new address[](2);
+        baseImpls[0] = address(0);
+        baseImpls[1] = makeAddr("baseImpl");
+        address upgradeImpl = address(0);
+
+        // Should allow zero addresses (no validation in contract)
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(address(0), address(0)));
+        assertTrue(hookUpgradeGate.isRegisteredUpgradePath(makeAddr("baseImpl"), address(0)));
+    }
+
+    function test_hookUpgradeGate_isAllowedHookUpgradeMapping() public {
+        address baseImpl = makeAddr("baseImpl");
+        address upgradeImpl = makeAddr("upgradeImpl");
+
+        // Test direct mapping access
+        assertFalse(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl));
+
+        // Register upgrade path
+        address[] memory baseImpls = new address[](1);
+        baseImpls[0] = baseImpl;
+        vm.prank(hookUpgradeGate.owner());
+        hookUpgradeGate.registerUpgradePath(baseImpls, upgradeImpl);
+
+        // Test direct mapping access
+        assertTrue(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl));
+
+        // Should match isRegisteredUpgradePath
+        assertEq(hookUpgradeGate.isAllowedHookUpgrade(baseImpl, upgradeImpl), hookUpgradeGate.isRegisteredUpgradePath(baseImpl, upgradeImpl));
+    }
 }

package/test/MultiOwnable.t.sol

@@ -7,13 +7,13 @@ contract MultiOwnableTest is BaseTest {
     function setUp() public override {
         super.setUp();
 
-        _deployCoin();
+        _deployV4Coin();
     }
 
     function test_initial_owners() public view {
-        assertEq(coin.owners().length, 1);
-        assertEq(coin.owners()[0], users.creator);
-        assertEq(coin.isOwner(users.creator), true);
+        assertEq(coinV4.owners().length, 1);
+        assertEq(coinV4.owners()[0], users.creator);
+        assertEq(coinV4.isOwner(users.creator), true);
     }
 
     function test_add_owners() public {
@@ -22,21 +22,21 @@ contract MultiOwnableTest is BaseTest {
         newOwners[1] = makeAddr("NewOwner2");
 
         vm.prank(users.creator);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
 
-        assertEq(coin.owners().length, 3);
-        assertEq(coin.isOwner(users.creator), true);
-        assertEq(coin.isOwner(newOwners[0]), true);
-        assertEq(coin.isOwner(newOwners[1]), true);
+        assertEq(coinV4.owners().length, 3);
+        assertEq(coinV4.isOwner(users.creator), true);
+        assertEq(coinV4.isOwner(newOwners[0]), true);
+        assertEq(coinV4.isOwner(newOwners[1]), true);
     }
 
     function test_add_owner() public {
         vm.prank(users.creator);
-        coin.addOwner(address(this));
+        coinV4.addOwner(address(this));
 
-        assertEq(coin.owners().length, 2);
-        assertEq(coin.isOwner(users.creator), true);
-        assertEq(coin.isOwner(address(this)), true);
+        assertEq(coinV4.owners().length, 2);
+        assertEq(coinV4.isOwner(users.creator), true);
+        assertEq(coinV4.isOwner(address(this)), true);
     }
 
     function test_remove_owners() public {
@@ -45,67 +45,67 @@ contract MultiOwnableTest is BaseTest {
         newOwners[1] = makeAddr("NewOwner2");
 
         vm.prank(users.creator);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
 
         vm.prank(users.creator);
-        coin.removeOwners(newOwners);
+        coinV4.removeOwners(newOwners);
 
-        assertEq(coin.owners().length, 1);
-        assertEq(coin.isOwner(users.creator), true);
-        assertEq(coin.isOwner(newOwners[0]), false);
-        assertEq(coin.isOwner(newOwners[1]), false);
+        assertEq(coinV4.owners().length, 1);
+        assertEq(coinV4.isOwner(users.creator), true);
+        assertEq(coinV4.isOwner(newOwners[0]), false);
+        assertEq(coinV4.isOwner(newOwners[1]), false);
     }
 
     function test_remove_owner() public {
         vm.prank(users.creator);
-        coin.addOwner(address(this));
+        coinV4.addOwner(address(this));
 
         vm.prank(address(this));
-        coin.removeOwner(users.creator);
+        coinV4.removeOwner(users.creator);
 
-        assertEq(coin.owners().length, 1);
-        assertEq(coin.isOwner(users.creator), false);
-        assertEq(coin.isOwner(address(this)), true);
+        assertEq(coinV4.owners().length, 1);
+        assertEq(coinV4.isOwner(users.creator), false);
+        assertEq(coinV4.isOwner(address(this)), true);
     }
 
     function test_revert_only_owner_can_add() public {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
-        coin.addOwner(address(this));
+        coinV4.addOwner(address(this));
     }
 
     function test_revert_only_owner_can_remove() public {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.OnlyOwner.selector));
 
         vm.prank(address(this));
-        coin.removeOwner(users.creator);
+        coinV4.removeOwner(users.creator);
     }
 
     function test_revert_cannot_remove_not_owner() public {
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.NotOwner.selector));
         vm.prank(users.creator);
-        coin.removeOwner(address(this));
+        coinV4.removeOwner(address(this));
     }
 
     function test_revert_last_owner_must_revoke() public {
         address newOwner = makeAddr("NewOwner1");
 
         vm.prank(users.creator);
-        coin.addOwner(newOwner);
+        coinV4.addOwner(newOwner);
 
         vm.prank(newOwner);
-        coin.removeOwner(users.creator);
+        coinV4.removeOwner(users.creator);
 
         vm.prank(newOwner);
         vm.expectRevert(abi.encodeWithSelector(MultiOwnable.UseRevokeOwnershipToRemoveSelf.selector));
-        coin.removeOwner(newOwner);
+        coinV4.removeOwner(newOwner);
     }
 
     function test_revoke_ownership() public {
         vm.prank(users.creator);
-        coin.revokeOwnership();
+        coinV4.revokeOwnership();
 
-        assertEq(coin.owners().length, 0);
-        assertEq(coin.isOwner(users.creator), false);
+        assertEq(coinV4.owners().length, 0);
+        assertEq(coinV4.isOwner(users.creator), false);
     }
 
     function test_revert_add_owners_with_zero_address() public {
@@ -116,7 +116,7 @@ contract MultiOwnableTest is BaseTest {
 
         vm.prank(users.creator);
         vm.expectRevert(MultiOwnable.OwnerCannotBeAddressZero.selector);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
     }
 
     function test_revert_add_owners_with_duplicate() public {
@@ -126,11 +126,11 @@ contract MultiOwnableTest is BaseTest {
         newOwners[1] = newOwner;
 
         vm.prank(users.creator);
-        coin.addOwner(newOwner);
+        coinV4.addOwner(newOwner);
 
         vm.expectRevert(MultiOwnable.AlreadyOwner.selector);
         vm.prank(users.creator);
-        coin.addOwners(newOwners);
+        coinV4.addOwners(newOwners);
     }
 
     function test_revert_init_with_zero_owners() public {

package/test/Upgrades.t.sol

@@ -6,7 +6,7 @@ import {ZoraFactoryImpl} from "../src/ZoraFactoryImpl.sol";
 import {BaseTest} from "./utils/BaseTest.sol";
 import {CoinsDeployerBase} from "../src/deployment/CoinsDeployerBase.sol";
 import {CoinConfigurationVersions} from "../src/libs/CoinConfigurationVersions.sol";
-import {ICoinV4} from "../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../src/interfaces/ICoin.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ISwapRouter} from "../src/interfaces/ISwapRouter.sol";
 import {IWETH} from "../src/interfaces/IWETH.sol";
@@ -43,13 +43,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -64,13 +58,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -88,19 +76,12 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
 
         ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(
-            factoryProxy.coinImpl(),
             factoryProxy.coinV4Impl(),
             factoryProxy.creatorCoinImpl(),
             address(contentCoinHook),
@@ -166,16 +147,16 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         );
 
         // do some swaps to test out
-        _swapSomeCurrencyForCoin(ICoinV4(coinAddress), ZORA, uint128(IERC20(ZORA).balanceOf(trader)), trader);
+        _swapSomeCurrencyForCoin(ICoin(coinAddress), ZORA, uint128(IERC20(ZORA).balanceOf(trader)), trader);
 
         // do some swaps to test out
-        _swapSomeCoinForCurrency(ICoinV4(coinAddress), ZORA, uint128(IERC20(coinAddress).balanceOf(trader)), trader);
+        _swapSomeCoinForCurrency(ICoin(coinAddress), ZORA, uint128(IERC20(coinAddress).balanceOf(trader)), trader);
     }
 
     address coinVersionLookup = 0x777777751622c0d3258f214F9DF38E35BF45baF3;
     address upgradeGate = 0xD88f6BdD765313CaFA5888C177c325E2C3AbF2D2;
 
-    function _swapSomeCurrencyForCoinAndExpectRevert(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+    function _swapSomeCurrencyForCoinAndExpectRevert(ICoin _coin, address currency, uint128 amountIn, address trader) internal {
         uint128 minAmountOut = uint128(0);
 
         (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
@@ -205,23 +186,23 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
 
-        address creatorCoin = ICoinV4(contentCoin).currency();
+        address creatorCoin = ICoin(contentCoin).currency();
 
         uint256 amountIn = IERC20(creatorCoin).balanceOf(trader);
 
         require(amountIn > 0, "no balance");
 
         // this swap should revert because the content coin is broken
-        _swapSomeCurrencyForCoinAndExpectRevert(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+        _swapSomeCurrencyForCoinAndExpectRevert(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
 
         bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
         // etch new hook into the content coin, it shouldn't revert anymore when swapping
-        vm.etch(address(ICoinV4(contentCoin).hooks()), address(newHook).code);
+        vm.etch(address(ICoin(contentCoin).hooks()), address(newHook).code);
 
-        _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
     }
 
     function test_canUpgradeBrokenContentCoinAndSwap() public {
@@ -231,7 +212,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address contentCoin = 0xB9799C839818bF50240CE683363D00c43a2E23b8;
 
-        address creatorCoin = ICoinV4(contentCoin).currency();
+        address creatorCoin = ICoin(contentCoin).currency();
 
         uint256 amountIn = 0.000111 ether;
 
@@ -239,7 +220,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
-        address existingHook = address(ICoinV4(contentCoin).hooks());
+        address existingHook = address(ICoin(contentCoin).hooks());
 
         address[] memory baseImpls = new address[](1);
         baseImpls[0] = existingHook;
@@ -251,7 +232,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         ContentCoin(contentCoin).migrateLiquidity(address(newHook), "");
 
         // do some swaps to test out
-        _swapSomeCurrencyForCoin(ICoinV4(contentCoin), creatorCoin, uint128(amountIn), trader);
+        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
     }
 
     function getPositionInfo(
@@ -272,7 +253,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         }
     }
 
-    function getLiquidityForPoolCoin(ICoinV4 coin) internal view returns (uint128[] memory liquidityForPositions) {
+    function getLiquidityForPoolCoin(ICoin coin) internal view returns (uint128[] memory liquidityForPositions) {
         return getLiquidityForPositions(coin.getPoolKey(), IZoraV4CoinHook(address(coin.hooks())).getPoolCoin(coin.getPoolKey()).positions);
     }
 
@@ -281,7 +262,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
 
-        ICoinV4 creatorCoin = ICoinV4(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
+        ICoin creatorCoin = ICoin(0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34);
 
         address zora = creatorCoin.currency();
 

package/test/utils/BaseTest.sol

@@ -12,7 +12,6 @@ import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/U
 import {IZoraFactory} from "../../src/interfaces/IZoraFactory.sol";
 import {ZoraFactoryImpl} from "../../src/ZoraFactoryImpl.sol";
 import {ZoraFactory} from "../../src/proxy/ZoraFactory.sol";
-import {Coin} from "../../src/Coin.sol";
 import {ContentCoin} from "../../src/ContentCoin.sol";
 import {MultiOwnable} from "../../src/utils/MultiOwnable.sol";
 import {ICoin} from "../../src/interfaces/ICoin.sol";
@@ -32,7 +31,7 @@ import {ContentCoinHook} from "../../src/hooks/ContentCoinHook.sol";
 import {HooksDeployment} from "../../src/libs/HooksDeployment.sol";
 import {CoinConstants} from "../../src/libs/CoinConstants.sol";
 import {ProxyShim} from "./ProxyShim.sol";
-import {ICoinV4} from "../../src/interfaces/ICoinV4.sol";
+import {ICoin} from "../../src/interfaces/ICoin.sol";
 import {UniV4SwapHelper} from "../../src/libs/UniV4SwapHelper.sol";
 import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
 import {IUniversalRouter} from "@uniswap/universal-router/contracts/interfaces/IUniversalRouter.sol";
@@ -81,7 +80,7 @@ contract BaseTest is Test, ContractAddresses {
     IAirlock internal airlock;
     Users internal users;
 
-    Coin internal coinV3Impl;
+    // Coin internal coinV3Impl;
     ContentCoin internal coinV4Impl;
     CreatorCoin internal creatorCoinImpl;
     ZoraFactoryImpl internal factoryImpl;
@@ -89,47 +88,16 @@ contract BaseTest is Test, ContractAddresses {
     ContentCoinHook internal contentCoinHook;
     CreatorCoinHook internal creatorCoinHook;
     HookUpgradeGate internal hookUpgradeGate;
-    Coin internal coin;
-
-    IUniswapV3Pool internal pool;
     int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = CoinConstants.DEFAULT_DISCOVERY_TICK_LOWER;
     int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = CoinConstants.DEFAULT_DISCOVERY_TICK_UPPER;
     uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = CoinConstants.DEFAULT_NUM_DISCOVERY_POSITIONS;
     uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = CoinConstants.DEFAULT_DISCOVERY_SUPPLY_SHARE;
 
-    function _deployCoin() internal {
-        bytes memory poolConfig_ = _generatePoolConfig(
-            CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
-            address(weth),
-            DEFAULT_DISCOVERY_TICK_LOWER,
-            DEFAULT_DISCOVERY_TICK_UPPER,
-            DEFAULT_NUM_DISCOVERY_POSITIONS,
-            DEFAULT_DISCOVERY_SUPPLY_SHARE
-        );
-        vm.prank(users.creator);
-        (address coinAddress, ) = factory.deploy(
-            users.creator,
-            _getDefaultOwners(),
-            "https://test.com",
-            "Testcoin",
-            "TEST",
-            poolConfig_,
-            users.platformReferrer,
-            0
-        );
-
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
-    }
-
     function _defaultPoolConfig(address currency) internal pure returns (bytes memory) {
         return CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(currency);
     }
 
-    function _deployV4Coin(address currency) internal returns (ICoinV4) {
+    function _deployV4Coin(address currency) internal returns (ICoin) {
         bytes32 salt = keccak256(abi.encode(bytes("randomSalt")));
         return _deployV4Coin(currency, address(0), salt);
     }
@@ -137,7 +105,7 @@ contract BaseTest is Test, ContractAddresses {
     string constant DEFAULT_NAME = "Testcoin";
     string constant DEFAULT_SYMBOL = "TEST";
 
-    function _deployV4Coin(address currency, address createReferral, bytes32 salt) internal returns (ICoinV4) {
+    function _deployV4Coin(address currency, address createReferral, bytes32 salt) internal returns (ICoin) {
         address[] memory owners = new address[](1);
         owners[0] = users.creator;
 
@@ -161,15 +129,13 @@ contract BaseTest is Test, ContractAddresses {
         return coinV4;
     }
 
+    function _deployV4Coin() internal returns (ICoin) {
+        // deploy with eth and no referral
+        return _deployV4Coin(address(0), address(0), bytes32(0));
+    }
+
     function _deployCoinUSDCPair() internal {
-        bytes memory poolConfig_ = _generatePoolConfig(
-            CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
-            USDC_ADDRESS,
-            DEFAULT_DISCOVERY_TICK_LOWER,
-            DEFAULT_DISCOVERY_TICK_UPPER,
-            DEFAULT_NUM_DISCOVERY_POSITIONS,
-            DEFAULT_DISCOVERY_SUPPLY_SHARE
-        );
+        bytes memory poolConfig_ = _defaultPoolConfig(USDC_ADDRESS);
         vm.prank(users.creator);
         (address coinAddress, ) = factory.deploy(
             users.creator,
@@ -182,18 +148,14 @@ contract BaseTest is Test, ContractAddresses {
             0
         );
 
-        coin = Coin(payable(coinAddress));
-        pool = IUniswapV3Pool(coin.poolAddress());
-
-        vm.label(address(coin), "COIN");
-        vm.label(address(pool), "POOL");
+        vm.label(coinAddress, "COIN");
     }
 
-    function _swapSomeCurrencyForCoin(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+    function _swapSomeCurrencyForCoin(ICoin _coin, address currency, uint128 amountIn, address trader) internal {
         _swapSomeCurrencyForCoin(_coin.getPoolKey(), _coin, currency, amountIn, trader);
     }
 
-    function _swapSomeCurrencyForCoin(PoolKey memory poolKey, ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+    function _swapSomeCurrencyForCoin(PoolKey memory poolKey, ICoin _coin, address currency, uint128 amountIn, address trader) internal {
         uint128 minAmountOut = uint128(0);
 
         (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
@@ -219,7 +181,7 @@ contract BaseTest is Test, ContractAddresses {
         vm.stopPrank();
     }
 
-    function _swapSomeCoinForCurrency(ICoinV4 _coin, address currency, uint128 amountIn, address trader) internal {
+    function _swapSomeCoinForCurrency(ICoin _coin, address currency, uint128 amountIn, address trader) internal {
         uint128 minAmountOut = uint128(0);
 
         (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
@@ -326,7 +288,6 @@ contract BaseTest is Test, ContractAddresses {
 
         ProxyShim mockUpgradeableImpl = new ProxyShim();
         factory = IZoraFactory(address(new ZoraFactory(address(mockUpgradeableImpl))));
-        coinV3Impl = new Coin(users.feeRecipient, address(protocolRewards), WETH_ADDRESS, V3_FACTORY, SWAP_ROUTER, DOPPLER_AIRLOCK);
 
         hookUpgradeGate = new HookUpgradeGate(users.factoryOwner);
 
@@ -336,13 +297,7 @@ contract BaseTest is Test, ContractAddresses {
 
         creatorCoinImpl = new CreatorCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK);
 
-        factoryImpl = new ZoraFactoryImpl(
-            address(coinV3Impl),
-            address(coinV4Impl),
-            address(creatorCoinImpl),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
         UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
         factory = IZoraFactory(address(factory));
 
@@ -419,15 +374,7 @@ contract BaseTest is Test, ContractAddresses {
     }
 
     function _generatePoolConfig(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 CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(currency_);
     }
 
     function _generatePoolConfig(