@zoralabs/coins 2.1.1 → 2.2.1

package/test/Upgrades.t.sol

@@ -13,7 +13,7 @@ import {IWETH} from "../src/interfaces/IWETH.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {BuySupplyWithSwapRouterHook} from "../src/hooks/deployment/BuySupplyWithSwapRouterHook.sol";
-import {ContentCoinHook} from "../src/hooks/ContentCoinHook.sol";
+import {ZoraV4CoinHook} from "../src/hooks/ZoraV4CoinHook.sol";
 import {console} from "forge-std/console.sol";
 import {IDeployedCoinVersionLookup} from "../src/interfaces/IDeployedCoinVersionLookup.sol";
 import {IHooksUpgradeGate} from "../src/interfaces/IHooksUpgradeGate.sol";
@@ -43,7 +43,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -58,7 +58,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
 
         vm.prank(factoryProxy.owner());
         factoryProxy.upgradeToAndCall(address(newImpl), "");
@@ -70,29 +70,25 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         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);
+    // This fork test needs to be updated after hook registry + new factory is deployed
+    // 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);
+    //     factoryProxy = ZoraFactoryImpl(0x777777751622c0d3258f214F9DF38E35BF45baF3);
 
-        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+    // ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
 
-        vm.prank(factoryProxy.owner());
-        factoryProxy.upgradeToAndCall(address(newImpl), "");
+    //     vm.prank(factoryProxy.owner());
+    //     factoryProxy.upgradeToAndCall(address(newImpl), "");
 
-        ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(
-            factoryProxy.coinV4Impl(),
-            factoryProxy.creatorCoinImpl(),
-            address(contentCoinHook),
-            address(creatorCoinHook)
-        );
+    // ZoraFactoryImpl newImpl2 = new ZoraFactoryImpl(factoryProxy.coinV4Impl(), factoryProxy.creatorCoinImpl(), address(hook), address(zoraHookRegistry));
 
-        vm.prank(factoryProxy.owner());
-        factoryProxy.upgradeToAndCall(address(newImpl2), "");
+    //     vm.prank(factoryProxy.owner());
+    //     factoryProxy.upgradeToAndCall(address(newImpl2), "");
 
-        assertEq(factoryProxy.implementation(), address(newImpl2));
-    }
+    //     assertEq(factoryProxy.implementation(), address(newImpl2));
+    // }
 
     function test_canUpgradeAndSwap() public {
         vm.createSelectFork("base");
@@ -179,32 +175,6 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         vm.stopPrank();
     }
 
-    function test_canCanFixBrokenContentCoinAndSwap() public {
-        vm.createSelectFork("base", 31835069);
-
-        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
-
-        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
-
-        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(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(ICoin(contentCoin).hooks()), address(newHook).code);
-
-        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
-    }
-
     function test_canUpgradeBrokenContentCoinAndSwap() public {
         vm.createSelectFork("base", 32613149);
 
@@ -216,7 +186,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         uint256 amountIn = 0.000111 ether;
 
-        bytes memory creationCode = HooksDeployment.contentCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -268,7 +238,7 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
 
         address existingHook = address(creatorCoin.hooks());
 
-        bytes memory creationCode = HooksDeployment.creatorCoinCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(address(poolManager), coinVersionLookup, new address[](0), upgradeGate);
 
         (IHooks newHook, ) = HooksDeployment.deployHookWithExistingOrNewSalt(address(this), creationCode, bytes32(0));
 
@@ -319,4 +289,30 @@ contract UpgradesTest is BaseTest, CoinsDeployerBase {
         // now try to swap some currency for the creator coin - it should succeed
         _swapSomeCurrencyForCoin(creatorCoin, zora, uint128(IERC20(zora).balanceOf(trader) / 2), trader);
     }
+
+    function test_canFixBrokenContentCoinAndSwap() public {
+        vm.createSelectFork("base", 31835069);
+
+        address trader = 0xf69fEc6d858c77e969509843852178bd24CAd2B6;
+
+        address contentCoin = 0x4E93A01c90f812284F71291a8d1415a904957156;
+
+        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(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+
+        bytes memory creationCode = HooksDeployment.makeHookCreationCode(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(ICoin(contentCoin).hooks()), address(newHook).code);
+
+        _swapSomeCurrencyForCoin(ICoin(contentCoin), creatorCoin, uint128(amountIn), trader);
+    }
 }

package/test/ZoraHookRegistry.t.sol

@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.28;
+
+import "forge-std/Test.sol";
+
+import {IZoraHookRegistry} from "../src/interfaces/IZoraHookRegistry.sol";
+import {ZoraHookRegistry} from "../src/hook-registry/ZoraHookRegistry.sol";
+
+contract MockHook {
+    function contractVersion() public pure returns (string memory) {
+        return "0.0.0";
+    }
+}
+
+contract ZoraHookRegistryTest is Test {
+    uint256 internal forkId;
+    address internal owner;
+
+    ZoraHookRegistry internal zoraHookRegistry;
+    MockHook internal mockHook;
+
+    function setUp() public {
+        forkId = vm.createSelectFork("base", 34509280);
+        owner = makeAddr("owner");
+
+        address[] memory initialOwners = new address[](1);
+        initialOwners[0] = owner;
+
+        zoraHookRegistry = new ZoraHookRegistry();
+        zoraHookRegistry.initialize(initialOwners);
+
+        mockHook = new MockHook();
+    }
+
+    function test_register_hooks() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), true);
+
+        address[] memory addrs = zoraHookRegistry.getHookAddresses();
+        assertEq(addrs.length, 1);
+        assertEq(addrs[0], hooks[0]);
+
+        assertEq(zoraHookRegistry.getHookTag(hooks[0]), tags[0]);
+
+        IZoraHookRegistry.ZoraHook[] memory zoraHooks = zoraHookRegistry.getHooks();
+        assertEq(zoraHooks.length, 1);
+        assertEq(zoraHooks[0].hook, hooks[0]);
+        assertEq(zoraHooks[0].tag, "ZoraHook");
+        assertEq(zoraHooks[0].version, "0.0.0");
+    }
+
+    function test_revert_register_hooks_only_owner() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.expectRevert(abi.encodeWithSignature("OnlyOwner()"));
+        vm.prank(makeAddr("notOwner"));
+        zoraHookRegistry.registerHooks(hooks, tags);
+    }
+
+    function test_revert_register_hooks_array_length_mismatch() public {
+        address[] memory hooks = new address[](2);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        hooks[1] = makeAddr("anotherHook");
+        tags[0] = "Tag0";
+
+        vm.prank(owner);
+        vm.expectRevert(abi.encodeWithSignature("ArrayLengthMismatch()"));
+        zoraHookRegistry.registerHooks(hooks, tags);
+    }
+
+    function test_register_duplicate_is_idempotent() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.startPrank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+        zoraHookRegistry.registerHooks(hooks, tags);
+        vm.stopPrank();
+
+        assertEq(zoraHookRegistry.getHookAddresses().length, 1);
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), true);
+    }
+
+    function test_remove_hooks() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(hooks);
+
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), false);
+        assertEq(zoraHookRegistry.getHookAddresses().length, 0);
+        assertEq(zoraHookRegistry.getHookTag(hooks[0]), "");
+    }
+
+    function test_revert_remove_hooks_only_owner() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        vm.expectRevert(abi.encodeWithSignature("OnlyOwner()"));
+        vm.prank(makeAddr("notOwner"));
+        zoraHookRegistry.removeHooks(hooks);
+    }
+
+    function test_remove_unregistered_noop() public {
+        address[] memory hooks = new address[](1);
+        hooks[0] = makeAddr("unregistered");
+
+        uint256 beforeLen = zoraHookRegistry.getHookAddresses().length;
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(hooks);
+
+        assertEq(zoraHookRegistry.getHookAddresses().length, beforeLen);
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), false);
+    }
+
+    function test_emit_register_hooks_event() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.expectEmit(true, true, true, false, address(zoraHookRegistry));
+        emit IZoraHookRegistry.ZoraHookRegistered(hooks[0], tags[0], "0.0.0");
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+    }
+
+    function test_emit_remove_hooks_event() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        vm.expectEmit(true, true, true, false, address(zoraHookRegistry));
+        emit IZoraHookRegistry.ZoraHookRemoved(hooks[0], tags[0], "0.0.0");
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(hooks);
+    }
+
+    function test_hook_version() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = 0x81542dC43Aff247eff4a0eceFC286A2973aE1040;
+        tags[0] = "CONTENT";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        assertEq(zoraHookRegistry.getHookVersion(hooks[0]), "1.1.1");
+    }
+
+    function test_hook_version_not_found() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = 0xA1eBdD5cA6470Bbd67114331387f2dDa7bfad040;
+        tags[0] = "CONTENT";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        assertEq(zoraHookRegistry.getHookVersion(hooks[0]), "");
+    }
+
+    function test_is_registered_hook_false_when_never_registered() public view {
+        assertEq(zoraHookRegistry.isRegisteredHook(address(this)), false);
+    }
+
+    function test_get_hook_addresses_multiple_and_remove_middle() public {
+        address a = address(mockHook);
+        address b = address(new MockHook());
+        address c = address(new MockHook());
+
+        address[] memory hooks = new address[](3);
+        string[] memory tags = new string[](3);
+        hooks[0] = a;
+        tags[0] = "A";
+        hooks[1] = b;
+        tags[1] = "B";
+        hooks[2] = c;
+        tags[2] = "C";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        address[] memory removeB = new address[](1);
+        removeB[0] = b;
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(removeB);
+
+        address[] memory addrs = zoraHookRegistry.getHookAddresses();
+        assertEq(addrs.length, 2);
+
+        bool hasA;
+        bool hasC;
+        for (uint256 i = 0; i < addrs.length; i++) {
+            if (addrs[i] == a) hasA = true;
+            if (addrs[i] == c) hasC = true;
+            assertTrue(addrs[i] != b);
+        }
+        assertTrue(hasA);
+        assertTrue(hasC);
+
+        assertEq(zoraHookRegistry.getHookTag(a), "A");
+        assertEq(zoraHookRegistry.getHookTag(b), "");
+        assertEq(zoraHookRegistry.getHookTag(c), "C");
+
+        IZoraHookRegistry.ZoraHook[] memory full = zoraHookRegistry.getHooks();
+        assertEq(full.length, 2);
+
+        bool okA;
+        bool okC;
+        for (uint256 i = 0; i < full.length; i++) {
+            if (full[i].hook == a) {
+                assertEq(full[i].tag, "A");
+                assertEq(full[i].version, "0.0.0");
+                okA = true;
+            } else if (full[i].hook == c) {
+                assertEq(full[i].tag, "C");
+                assertEq(full[i].version, "0.0.0");
+                okC = true;
+            }
+        }
+        assertTrue(okA && okC);
+    }
+}

package/test/utils/BaseTest.sol

@@ -27,7 +27,7 @@ import {ProtocolRewards} from "../utils/ProtocolRewards.sol";
 import {MarketConstants} from "../../src/libs/MarketConstants.sol";
 import {CoinConfigurationVersions} from "../../src/libs/CoinConfigurationVersions.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
-import {ContentCoinHook} from "../../src/hooks/ContentCoinHook.sol";
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
 import {HooksDeployment} from "../../src/libs/HooksDeployment.sol";
 import {CoinConstants} from "../../src/libs/CoinConstants.sol";
 import {ProxyShim} from "./ProxyShim.sol";
@@ -41,15 +41,19 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {CreatorCoin} from "../../src/CreatorCoin.sol";
-import {CreatorCoinHook} from "../../src/hooks/CreatorCoinHook.sol";
 import {ContractAddresses} from "./ContractAddresses.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {HookUpgradeGate} from "../../src/hooks/HookUpgradeGate.sol";
+import {ZoraHookRegistry} from "../../src/hook-registry/ZoraHookRegistry.sol";
 
 contract BaseTest is Test, ContractAddresses {
     using stdStorage for StdStorage;
 
     int24 internal constant USDC_TICK_LOWER = 57200;
+    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;
 
     struct Users {
         address factoryOwner;
@@ -85,13 +89,9 @@ contract BaseTest is Test, ContractAddresses {
     CreatorCoin internal creatorCoinImpl;
     ZoraFactoryImpl internal factoryImpl;
     IZoraFactory internal factory;
-    ContentCoinHook internal contentCoinHook;
-    CreatorCoinHook internal creatorCoinHook;
+    ZoraV4CoinHook internal hook;
     HookUpgradeGate internal hookUpgradeGate;
-    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;
+    ZoraHookRegistry internal zoraHookRegistry;
 
     function _defaultPoolConfig(address currency) internal pure returns (bytes memory) {
         return CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(currency);
@@ -203,28 +203,14 @@ contract BaseTest is Test, ContractAddresses {
         vm.stopPrank();
     }
 
-    function _deployFeeEstimatorHook(uint256 initialSupplyForPositions, address hooks) internal {
-        deployCodeTo("FeeEstimatorHook.sol", abi.encode(V4_POOL_MANAGER, address(factory), hookUpgradeGate, initialSupplyForPositions), hooks);
+    function _deployFeeEstimatorHook(address hooks) internal {
+        deployCodeTo("FeeEstimatorHook.sol", abi.encode(V4_POOL_MANAGER, address(factory), hookUpgradeGate), hooks);
     }
 
-    function getSalts(address[] memory trustedMessageSenders) public returns (bytes32 contentCoinSalt, bytes32 creatorCoinSalt) {
+    function getSalt(address[] memory trustedMessageSenders) public returns (bytes32 hookSalt) {
         address deployer = address(this);
 
-        (, contentCoinSalt) = HooksDeployment.mineForContentCoinSalt(
-            deployer,
-            V4_POOL_MANAGER,
-            address(factory),
-            trustedMessageSenders,
-            address(hookUpgradeGate)
-        );
-
-        (, creatorCoinSalt) = HooksDeployment.mineForCreatorCoinSalt(
-            deployer,
-            V4_POOL_MANAGER,
-            address(factory),
-            trustedMessageSenders,
-            address(hookUpgradeGate)
-        );
+        (, hookSalt) = HooksDeployment.mineForCoinSalt(deployer, V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate));
     }
 
     function _deployHooks() internal {
@@ -232,24 +218,14 @@ contract BaseTest is Test, ContractAddresses {
         trustedMessageSenders[0] = UNIVERSAL_ROUTER;
         trustedMessageSenders[1] = V4_POSITION_MANAGER;
 
-        (bytes32 contentCoinSalt, bytes32 creatorCoinSalt) = getSalts(trustedMessageSenders);
+        bytes32 hookSalt = getSalt(trustedMessageSenders);
 
-        contentCoinHook = ContentCoinHook(
-            payable(
-                address(
-                    HooksDeployment.deployHookWithSalt(
-                        HooksDeployment.contentCoinCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
-                        contentCoinSalt
-                    )
-                )
-            )
-        );
-        creatorCoinHook = CreatorCoinHook(
+        hook = ZoraV4CoinHook(
             payable(
                 address(
                     HooksDeployment.deployHookWithSalt(
-                        HooksDeployment.creatorCoinHookCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
-                        creatorCoinSalt
+                        HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
+                        hookSalt
                     )
                 )
             )
@@ -291,13 +267,20 @@ contract BaseTest is Test, ContractAddresses {
 
         hookUpgradeGate = new HookUpgradeGate(users.factoryOwner);
 
+        zoraHookRegistry = new ZoraHookRegistry();
+
+        address[] memory initialOwners = new address[](2);
+        initialOwners[0] = users.factoryOwner;
+        initialOwners[1] = address(factory);
+        zoraHookRegistry.initialize(initialOwners);
+
         _deployHooks();
 
         coinV4Impl = new ContentCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK);
 
         creatorCoinImpl = new CreatorCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK);
 
-        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
         UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
         factory = IZoraFactory(address(factory));
 
@@ -317,7 +300,7 @@ contract BaseTest is Test, ContractAddresses {
         vm.label(address(V4_QUOTER), "V4_QUOTER");
         vm.label(address(V4_PERMIT2), "V4_PERMIT2");
         vm.label(address(UNIVERSAL_ROUTER), "UNIVERSAL_ROUTER");
-        vm.label(address(creatorCoinHook), "CREATOR_COIN_HOOK");
+        vm.label(address(hook), "HOOK");
     }
 
     struct TradeRewards {

package/test/utils/FeeEstimatorHook.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import {ContentCoinHook} from "../../src/hooks/ContentCoinHook.sol";
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
 import {IPoolManager, PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {IDeployedCoinVersionLookup} from "../../src/interfaces/IDeployedCoinVersionLookup.sol";
 import {IHasRewardsRecipients} from "../../src/interfaces/IHasRewardsRecipients.sol";
@@ -15,11 +15,10 @@ import {ICoin, IHasSwapPath} from "../../src/interfaces/ICoin.sol";
 import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
-import {BaseZoraV4CoinHook} from "../../src/hooks/BaseZoraV4CoinHook.sol";
 import {IHooksUpgradeGate} from "../../src/interfaces/IHooksUpgradeGate.sol";
 
 /// @dev Test util - meant to be able to etched where a normal zora hook is, to gather the fees from swaps but not distribute them
-contract FeeEstimatorHook is BaseZoraV4CoinHook {
+contract FeeEstimatorHook is ZoraV4CoinHook {
     struct FeeEstimatorState {
         uint128 fees0;
         uint128 fees1;
@@ -34,9 +33,8 @@ contract FeeEstimatorHook is BaseZoraV4CoinHook {
     constructor(
         IPoolManager _poolManager,
         IDeployedCoinVersionLookup _coinVersionLookup,
-        IHooksUpgradeGate upgradeGate,
-        uint256 initialSupplyForPositions
-    ) BaseZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0), upgradeGate, initialSupplyForPositions) {}
+        IHooksUpgradeGate upgradeGate
+    ) ZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0), upgradeGate) {}
 
     FeeEstimatorState public feeState;