@zoralabs/coins 2.1.2 → 2.2.1

package/test/CreatorCoinRewards.t.sol

@@ -0,0 +1,375 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "./utils/BaseTest.sol";
+import {console} from "forge-std/console.sol";
+
+import {ICreatorCoin} from "../src/interfaces/ICreatorCoin.sol";
+import {ICreatorCoinHook} from "../src/interfaces/ICreatorCoinHook.sol";
+import {IHasRewardsRecipients} from "../src/interfaces/IHasRewardsRecipients.sol";
+import {CoinRewardsV4} from "../src/libs/CoinRewardsV4.sol";
+import {UniV4SwapHelper} from "../src/libs/UniV4SwapHelper.sol";
+import {FeeEstimatorHook} from "./utils/FeeEstimatorHook.sol";
+import {RewardTestHelpers, RewardBalances} from "./utils/RewardTestHelpers.sol";
+import {CoinConstants} from "../src/libs/CoinConstants.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract CreatorCoinRewardsTest is BaseTest {
+    CreatorCoin internal creatorCoin;
+
+    address internal platformReferrer;
+    address internal tradeReferrer;
+
+    function setUp() public override {
+        super.setUpWithBlockNumber(30267794);
+
+        deal(address(zoraToken), address(poolManager), 1_000_000_000e18);
+
+        // Set up referrer addresses for all tests
+        platformReferrer = makeAddr("platformReferrer");
+        tradeReferrer = makeAddr("tradeReferrer");
+    }
+
+    function _getMultiCurvePoolConfig() internal view returns (bytes memory) {
+        int24[] memory tickLower = new int24[](1);
+        int24[] memory tickUpper = new int24[](1);
+        uint16[] memory numDiscoveryPositions = new uint16[](1);
+        uint256[] memory maxDiscoverySupplyShare = new uint256[](1);
+
+        tickLower[0] = -138_000;
+        tickUpper[0] = 81_000;
+        numDiscoveryPositions[0] = 11;
+        maxDiscoverySupplyShare[0] = 0.25e18;
+
+        return
+            abi.encode(
+                CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION,
+                address(zoraToken),
+                tickLower,
+                tickUpper,
+                numDiscoveryPositions,
+                maxDiscoverySupplyShare
+            );
+    }
+
+    function _deployCreatorCoin(bool hasPlatformReferrer) internal {
+        bytes memory poolConfig = _getMultiCurvePoolConfig();
+
+        // Generate unique salt based on referrer addresses and block timestamp
+        bytes32 uniqueSalt = keccak256(abi.encodePacked(platformReferrer, block.timestamp, gasleft()));
+
+        vm.prank(users.creator);
+        address creatorCoinAddress = factory.deployCreatorCoin(
+            users.creator,
+            _getDefaultOwners(),
+            "https://test.com",
+            "Testcoin",
+            "TEST",
+            poolConfig,
+            hasPlatformReferrer ? platformReferrer : address(0),
+            uniqueSalt // unique salt to prevent collisions
+        );
+
+        creatorCoin = CreatorCoin(creatorCoinAddress);
+        vm.label(address(creatorCoin), "TEST_CREATOR_COIN");
+    }
+
+    /// @dev Estimates the fees from a swap, by deploying a test hook that doesn't distribute the fees
+    /// and then reverting the state after the swap
+    function _estimateLpFees(bytes memory commands, bytes[] memory inputs) internal returns (FeeEstimatorHook.FeeEstimatorState memory feeState) {
+        uint256 snapshot = vm.snapshotState();
+        _deployFeeEstimatorHook(address(hook));
+
+        // Execute the swap
+        uint256 deadline = block.timestamp + 20;
+        router.execute(commands, inputs, deadline);
+
+        feeState = FeeEstimatorHook(payable(address(hook))).getFeeState();
+
+        vm.revertToState(snapshot);
+    }
+
+    // Generic function to record token balances for all reward recipients
+    function _recordBalances(IERC20 token) internal view returns (RewardBalances memory balances) {
+        balances.creator = token.balanceOf(users.creator);
+        balances.platformReferrer = token.balanceOf(platformReferrer);
+        balances.tradeReferrer = token.balanceOf(tradeReferrer);
+        balances.protocol = token.balanceOf(creatorCoin.protocolRewardRecipient());
+        balances.doppler = token.balanceOf(creatorCoin.dopplerFeeRecipient());
+    }
+
+    // Helper function to record initial ZORA token balances for all reward recipients
+    function _recordZoraBalances() internal view returns (RewardBalances memory balances) {
+        return _recordBalances(zoraToken);
+    }
+
+    // Helper function to record initial creator coin balances for all reward recipients
+    function _recordCreatorCoinBalances() internal view returns (RewardBalances memory balances) {
+        return _recordBalances(IERC20(address(creatorCoin)));
+    }
+
+    // Legacy function for backward compatibility
+    function _recordInitialBalances() internal view returns (RewardBalances memory balances) {
+        return _recordZoraBalances();
+    }
+
+    // Helper function to calculate ZORA token reward deltas after trade
+    function _calculateZoraRewardDeltas(RewardBalances memory initialBalances) internal view returns (RewardBalances memory deltas) {
+        return
+            RewardTestHelpers.calculateTokenRewardDeltas(
+                initialBalances,
+                zoraToken,
+                users.creator,
+                platformReferrer,
+                tradeReferrer,
+                creatorCoin.protocolRewardRecipient(),
+                creatorCoin.dopplerFeeRecipient()
+            );
+    }
+
+    // Helper function to calculate creator coin reward deltas after trade
+    function _calculateCreatorCoinRewardDeltas(RewardBalances memory initialBalances) internal view returns (RewardBalances memory deltas) {
+        deltas.creator = creatorCoin.balanceOf(users.creator) - initialBalances.creator;
+        // creatorReferrer is now unified with platformReferrer
+        deltas.platformReferrer = creatorCoin.balanceOf(platformReferrer) - initialBalances.platformReferrer;
+        deltas.tradeReferrer = creatorCoin.balanceOf(tradeReferrer) - initialBalances.tradeReferrer;
+        deltas.protocol = creatorCoin.balanceOf(creatorCoin.protocolRewardRecipient()) - initialBalances.protocol;
+        deltas.doppler = creatorCoin.balanceOf(creatorCoin.dopplerFeeRecipient()) - initialBalances.doppler;
+    }
+
+    // Legacy function for backward compatibility
+    function _calculateRewardDeltas(RewardBalances memory initialBalances) internal view returns (RewardBalances memory deltas) {
+        return _calculateZoraRewardDeltas(initialBalances);
+    }
+
+    // Helper function to perform trades with optional trade referrer and return fee estimation
+    function _buyCreatorCoin(uint128 amountIn, bool hasTradeReferrer) internal returns (uint256 feeCurrency) {
+        deal(address(zoraToken), users.buyer, amountIn);
+
+        vm.warp(block.timestamp + 1 days);
+
+        vm.startPrank(users.buyer);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(zoraToken), uint128(amountIn), uint48(block.timestamp + 1 days));
+
+        // Build hook data with trade referrer if provided
+        bytes memory hookData = hasTradeReferrer ? abi.encode(tradeReferrer) : bytes("");
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(zoraToken),
+            uint128(amountIn),
+            address(creatorCoin),
+            0,
+            creatorCoin.getPoolKey(),
+            hookData
+        );
+
+        // Estimate the total fees (3%) before executing
+        FeeEstimatorHook.FeeEstimatorState memory feeState = _estimateLpFees(commands, inputs);
+
+        feeCurrency = feeState.afterSwapCurrencyAmount;
+
+        router.execute(commands, inputs, block.timestamp + 1 days);
+        vm.stopPrank();
+    }
+
+    // Helper function to sell creator coin for ZORA tokens
+    function _sellCreatorCoin(uint128 amountIn, bool hasTradeReferrer) internal returns (uint256 feeCurrency) {
+        vm.startPrank(users.buyer);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(creatorCoin), uint128(amountIn), uint48(block.timestamp + 1 days));
+
+        // Build hook data with trade referrer if provided
+        bytes memory hookData = hasTradeReferrer ? abi.encode(tradeReferrer) : bytes("");
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(creatorCoin),
+            uint128(amountIn),
+            address(zoraToken),
+            0,
+            creatorCoin.getPoolKey(),
+            hookData
+        );
+
+        // Estimate the fees before executing
+        FeeEstimatorHook.FeeEstimatorState memory feeState = _estimateLpFees(commands, inputs);
+
+        feeCurrency = feeState.afterSwapCurrencyAmount;
+
+        router.execute(commands, inputs, block.timestamp + 1 days);
+        vm.stopPrank();
+    }
+
+    /// @notice Test exact reward distribution percentages with platform referrer only
+    function test_rewards_platform_referrer_only() public {
+        // Deploy CreatorCoin with platform referrer
+        _deployCreatorCoin(true);
+
+        uint128 tradeAmount = 1000 ether; // 1000 ZORA tokens
+
+        // Record initial balances
+        RewardBalances memory initialBalances = _recordInitialBalances();
+
+        // Perform trade
+        uint256 zoraFees = _buyCreatorCoin(tradeAmount, false);
+
+        // Calculate reward deltas
+        RewardBalances memory rewards = _calculateRewardDeltas(initialBalances);
+
+        // Calculate market rewards from total fees
+        // Use estimated market rewards (already accounts for LP deduction and slippage)
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(zoraFees, true, false);
+        RewardTestHelpers.assertRewardsApproxEqRel(rewards, expected);
+    }
+
+    /// @notice Test exact reward distribution percentages with trade referrer only
+    function test_rewards_trade_referrer_only() public {
+        // Deploy CreatorCoin with no platform referrer
+        _deployCreatorCoin(false);
+
+        uint128 tradeAmount = 1000 ether; // 1000 ZORA tokens
+
+        // Record initial balances
+        RewardBalances memory initialBalances = _recordInitialBalances();
+
+        // Perform trade with trade referrer
+        uint256 zoraFees = _buyCreatorCoin(tradeAmount, true);
+
+        // Calculate reward deltas
+        RewardBalances memory rewards = _calculateRewardDeltas(initialBalances);
+
+        // Calculate market rewards from total fees
+        // Use estimated market rewards (already accounts for LP deduction and slippage)
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(zoraFees, false, true);
+        RewardTestHelpers.assertRewardsApproxEqRel(rewards, expected);
+    }
+
+    /// @notice Test exact reward distribution percentages with both platform and trade referrers
+    function test_rewards_both_referrers() public {
+        // Deploy CreatorCoin with platform referrer
+        _deployCreatorCoin(true);
+
+        uint128 tradeAmount = 1000 ether; // 1000 ZORA tokens
+
+        // Record initial balances
+        RewardBalances memory initialBalances = _recordInitialBalances();
+
+        // Perform trade with both referrers
+        uint256 zoraFees = _buyCreatorCoin(tradeAmount, true);
+
+        // Calculate reward deltas
+        RewardBalances memory rewards = _calculateRewardDeltas(initialBalances);
+
+        // Calculate market rewards from total fees
+        // Use estimated market rewards (already accounts for LP deduction and slippage)
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(zoraFees, true, true);
+        RewardTestHelpers.assertRewardsApproxEqRel(rewards, expected);
+    }
+
+    /// @notice Test exact reward distribution percentages with no referrers (baseline case)
+    function test_rewards_no_referrers() public {
+        // Deploy CreatorCoin with no platform referrer
+        _deployCreatorCoin(false);
+
+        uint128 tradeAmount = 1000 ether; // 1000 ZORA tokens
+
+        // Record initial balances
+        RewardBalances memory initialBalances = _recordInitialBalances();
+
+        // Perform trade with no trade referrer
+        uint256 zoraFees = _buyCreatorCoin(tradeAmount, false);
+
+        // Calculate reward deltas
+        RewardBalances memory rewards = _calculateRewardDeltas(initialBalances);
+
+        // Calculate market rewards from total fees
+        // Use estimated market rewards (already accounts for LP deduction and slippage)
+        RewardBalances memory expected = RewardTestHelpers.calculateExpectedRewards(zoraFees, false, false);
+        RewardTestHelpers.assertRewardsApproxEqRel(rewards, expected);
+    }
+
+    /// @notice Test buy-then-sell creator coin with both referrers set
+    function test_buy_then_sell_both_referrers() public {
+        uint128 buyAmount = 100 ether; // Fixed amount
+
+        // Deploy CreatorCoin with platform referrer
+        _deployCreatorCoin(true);
+
+        // Step 1: Buy creator coin (ZORA -> Creator Coin)
+        _buyCreatorCoin(buyAmount, true);
+
+        // Get buyer's creator coin balance after purchase
+        uint256 creatorCoinBalance = creatorCoin.balanceOf(users.buyer);
+        require(creatorCoinBalance > 0, "Buyer must have creator coin balance to sell");
+
+        // Record initial balances for both ZORA and creator coin
+        RewardBalances memory initialZoraBalances = _recordZoraBalances();
+
+        // Step 2: Sell creator coin (Creator Coin -> ZORA)
+        uint128 sellAmount = uint128(creatorCoinBalance);
+        uint256 sellZoraFees = _sellCreatorCoin(sellAmount, true);
+
+        // Calculate final reward deltas for both currencies
+        RewardBalances memory finalZoraRewards = _calculateZoraRewardDeltas(initialZoraBalances);
+
+        // Calculate total market rewards from both trades
+        RewardBalances memory expectedTotalRewards = RewardTestHelpers.calculateExpectedRewards(sellZoraFees, true, true);
+
+        // Validate ZORA token distributions (where all final rewards end up)
+        RewardTestHelpers.assertRewardsApproxEqRel(finalZoraRewards, expectedTotalRewards);
+    }
+
+    /// @notice Test that fee estimation matches actual total reward distribution
+    function test_estimateAfterSwapCurrencyAmount() public {
+        // Deploy CreatorCoin with platform referrer
+        _deployCreatorCoin(true);
+
+        uint128 tradeAmount = 1 ether; // Much smaller amount for testing
+
+        // Build swap command but don't execute yet
+        deal(address(zoraToken), users.buyer, tradeAmount);
+        vm.startPrank(users.buyer);
+        UniV4SwapHelper.approveTokenWithPermit2(permit2, address(router), address(zoraToken), tradeAmount, uint48(block.timestamp + 1 days));
+
+        (bytes memory commands, bytes[] memory inputs) = UniV4SwapHelper.buildExactInputSingleSwapCommand(
+            address(zoraToken),
+            tradeAmount,
+            address(creatorCoin),
+            0,
+            creatorCoin.getPoolKey(),
+            bytes("") // No trade referrer
+        );
+
+        // Estimate fees using FeeEstimatorHook
+        FeeEstimatorHook.FeeEstimatorState memory feeState = _estimateLpFees(commands, inputs);
+
+        // Record initial balances
+        RewardBalances memory initialBalances = _recordInitialBalances();
+
+        // Execute actual swap
+        router.execute(commands, inputs, block.timestamp + 20);
+        vm.stopPrank();
+
+        // Calculate total actual rewards distributed
+        RewardBalances memory finalRewards = _calculateZoraRewardDeltas(initialBalances);
+        uint256 totalActualRewards = finalRewards.creator +
+            finalRewards.platformReferrer +
+            finalRewards.tradeReferrer +
+            finalRewards.protocol +
+            finalRewards.doppler;
+
+        // Verify that total actual rewards match the estimated afterSwapCurrencyAmount
+        assertApproxEqRel(totalActualRewards, feeState.afterSwapCurrencyAmount, 0.25e18, "Total rewards should match estimated afterSwapCurrencyAmount");
+    }
+
+    function test_isLegacyCreatorCoinCategorization() public {
+        vm.createSelectFork("base", 31872861);
+
+        // Use the same creator coin from the upgrades test
+        address creatorCoinAddress = 0x2F03aB8fD97F5874bc3274C296Bb954Ae92EdA34;
+
+        // Test that the legacy creator coin is correctly categorized as a creator coin
+        bool isLegacy = CoinRewardsV4.isLegacyCreatorCoin(IHasRewardsRecipients(creatorCoinAddress));
+
+        assertTrue(isLegacy, "Legacy creator coin should be categorized as legacy creator coin");
+    }
+}

package/test/DeploymentHooks.t.sol

@@ -21,18 +21,18 @@ contract FakeHookNoInterface {
     }
 }
 
-contract HooksTest is BaseTest {
+contract DeploymentsHooksTest is BaseTest {
     address constant zora = 0x1111111111166b7FE7bd91427724B487980aFc69;
-    BuySupplyWithSwapRouterHook hook;
+    BuySupplyWithSwapRouterHook buySupplyWithSwapRouterHook;
 
     function _generateDefaultPoolConfig(address currency) internal pure returns (bytes memory) {
         return _generatePoolConfig(currency);
     }
 
     function setUp() public override {
-        super.setUpWithBlockNumber(29585474);
+        super.setUpWithBlockNumber(30267794);
 
-        hook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter), address(V4_POOL_MANAGER));
+        buySupplyWithSwapRouterHook = new BuySupplyWithSwapRouterHook(factory, address(swapRouter), address(V4_POOL_MANAGER));
     }
 
     function _deployWithHook(address _hook, bytes memory hookData, address currency) internal returns (address, bytes memory) {
@@ -46,7 +46,7 @@ contract HooksTest is BaseTest {
                 "TEST",
                 poolConfig,
                 users.platformReferrer,
-                _hook,
+                address(_hook),
                 hookData
             );
     }
@@ -77,7 +77,7 @@ contract HooksTest is BaseTest {
             users.creator,
             ISwapRouter.ExactInputParams({
                 path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
-                recipient: address(hook),
+                recipient: address(buySupplyWithSwapRouterHook),
                 amountIn: initialOrderSize,
                 amountOutMinimum: 0
             })
@@ -94,7 +94,7 @@ contract HooksTest is BaseTest {
             "TEST",
             poolConfig,
             users.platformReferrer,
-            address(hook),
+            address(buySupplyWithSwapRouterHook),
             hookData
         );
 
@@ -121,7 +121,7 @@ contract HooksTest is BaseTest {
                 ISwapRouter.exactOutputSingle.selector,
                 ISwapRouter.ExactOutputParams({
                     path: abi.encodePacked(address(weth), poolFee, USDC_ADDRESS, poolFee, zora),
-                    recipient: address(hook),
+                    recipient: address(buySupplyWithSwapRouterHook),
                     amountOut: 0.0001 ether,
                     amountInMaximum: 0
                 })
@@ -138,7 +138,7 @@ contract HooksTest is BaseTest {
             "TEST",
             _generateDefaultPoolConfig(zora),
             users.platformReferrer,
-            address(hook),
+            address(buySupplyWithSwapRouterHook),
             hookData
         );
     }
@@ -170,7 +170,7 @@ contract HooksTest is BaseTest {
             "TEST",
             _generateDefaultPoolConfig(zora),
             users.platformReferrer,
-            address(hook),
+            address(buySupplyWithSwapRouterHook),
             hookData
         );
     }

package/test/Factory.t.sol

@@ -13,7 +13,7 @@ contract FactoryTest is BaseTest {
 
     function test_factory_constructor_and_proxy_setup() public {
         // Impl constructor test
-        ZoraFactoryImpl impl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        ZoraFactoryImpl impl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
         assertEq(ZoraFactoryImpl(address(factory)).owner(), users.factoryOwner);
         assertEq(ZoraFactoryImpl(address(factory)).coinV4Impl(), address(coinV4Impl));
 
@@ -38,9 +38,7 @@ contract FactoryTest is BaseTest {
 
         assertEq(ZoraFactoryImpl(address(factory)).pendingOwner(), address(0));
 
-        address newFactoryImpl = address(
-            new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook))
-        );
+        address newFactoryImpl = address(new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry)));
 
         // Upgrade to current / new impl
         vm.prank(users.factoryOwner);
@@ -66,7 +64,7 @@ contract FactoryTest is BaseTest {
     }
 
     function test_upgrade() public {
-        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(users.factoryOwner);
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
@@ -82,12 +80,12 @@ contract FactoryTest is BaseTest {
         address newImpl = address(this);
 
         vm.prank(users.factoryOwner);
-        vm.expectRevert(abi.encodeWithSelector(ERC1967Utils.ERC1967InvalidImplementation.selector, address(newImpl)));
+        vm.expectRevert();
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
     }
 
     function test_revert_invalid_owner() public {
-        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(users.creator);
         vm.expectRevert(abi.encodeWithSelector(OwnableUpgradeable.OwnableUnauthorizedAccount.selector, users.creator));
@@ -163,6 +161,25 @@ contract FactoryTest is BaseTest {
         vm.expectRevert(abi.encodeWithSelector(IZoraFactory.UpgradeToMismatchedContractName.selector, "ZoraCoinFactory", "BadFactory"));
         ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(badImpl), "");
     }
+
+    function test_upgrade_auto_registers_hooks() public {
+        address[] memory registeredHooks;
+
+        registeredHooks = zoraHookRegistry.getHookAddresses();
+        assertEq(registeredHooks.length, 0);
+
+        _deployHooks(); // Deploys new content and creator coin hook addresses
+
+        // Deploy new factory impl with new content and creator coin hook addresses
+        ZoraFactoryImpl newImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
+
+        vm.prank(users.factoryOwner);
+        ZoraFactoryImpl(address(factory)).upgradeToAndCall(address(newImpl), "");
+
+        registeredHooks = zoraHookRegistry.getHookAddresses();
+        assertEq(registeredHooks.length, 1);
+        assertTrue(zoraHookRegistry.isRegisteredHook(address(hook)));
+    }
 }
 
 // Mock contracts for testing

package/test/HooksDeployment.t.sol

@@ -40,14 +40,14 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         vm.createSelectFork("base", 31653138);
 
         address[] memory trustedMessageSenders = new address[](0);
-        (, bytes32 salt) = HooksDeployment.mineForContentCoinSalt(
+        (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
             trustedMessageSenders,
             hookUpgradeGate
         );
-        IHooks hook = HooksDeployment.deployContentCoinHook(
+        IHooks hook = HooksDeployment.deployZoraV4CoinHook(
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
             trustedMessageSenders,
@@ -68,7 +68,7 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         vm.createSelectFork("base", 31653138);
 
         address[] memory trustedMessageSenders = new address[](0);
-        (, bytes32 salt) = HooksDeployment.mineForCreatorCoinSalt(
+        (, bytes32 salt) = HooksDeployment.mineForCoinSalt(
             address(this),
             V4_POOL_MANAGER,
             0x777777751622c0d3258f214F9DF38E35BF45baF3,
@@ -77,7 +77,7 @@ contract HooksDeploymentTest is Test, ContractAddresses {
         );
 
         IHooks hook = HooksDeployment.deployHookWithSalt(
-            HooksDeployment.creatorCoinHookCreationCode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, hookUpgradeGate),
+            HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, 0x777777751622c0d3258f214F9DF38E35BF45baF3, trustedMessageSenders, hookUpgradeGate),
             salt
         );
 

package/test/LiquidityMigration.t.sol

@@ -77,7 +77,7 @@ contract LiquidityMigrationTest is BaseTest {
         address[] memory trustedMessageSenders = new address[](1);
         trustedMessageSenders[0] = UNIVERSAL_ROUTER;
 
-        address originalHook = address(contentCoinHook);
+        address originalHook = address(hook);
 
         address newHook = address(new LiquidityMigrationReceiver());
 
@@ -109,7 +109,7 @@ contract LiquidityMigrationTest is BaseTest {
         assertEq(coinV4.balanceOf(address(originalHook)), originalHookCoinBalanceBefore, "original coin balance");
 
         // validate that the existing hook has no liquidity for its positions
-        LpPosition[] memory positions = contentCoinHook.getPoolCoin(poolKey).positions;
+        LpPosition[] memory positions = hook.getPoolCoin(poolKey).positions;
 
         for (uint256 i = 0; i < positions.length; i++) {
             uint128 liquidity = V4Liquidity.getLiquidity(poolManager, address(originalHook), poolKey, positions[i].tickLower, positions[i].tickUpper);
@@ -185,8 +185,6 @@ contract LiquidityMigrationTest is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
-        address originalHook = address(contentCoinHook);
-
         address invalidNewHook = address(new InvalidLiquidityMigrationReceiver());
 
         PoolKey memory poolKey = coinV4.getPoolKey();
@@ -203,14 +201,11 @@ contract LiquidityMigrationTest is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
-        address originalHook = address(contentCoinHook);
+        address originalHook = address(hook);
 
         address newHook = address(new LiquidityMigrationReceiver());
 
-        PoolKey memory poolKey = coinV4.getPoolKey();
-
         // Note: NOT registering the upgrade path
-
         // expect the migration to revert with UpgradePathNotRegistered error
         vm.prank(users.creator);
         vm.expectRevert(abi.encodeWithSelector(IUpgradeableV4Hook.UpgradePathNotRegistered.selector, originalHook, newHook));
@@ -221,7 +216,7 @@ contract LiquidityMigrationTest is BaseTest {
         address currency = address(mockERC20A);
         _deployV4Coin(currency);
 
-        address originalHook = address(contentCoinHook);
+        address originalHook = address(hook);
         address newHook = address(new LiquidityMigrationReceiver());
         PoolKey memory poolKey = coinV4.getPoolKey();