@zoralabs/coins 2.1.2 → 2.3.0

package/src/libs/CoinConstants.sol

@@ -8,53 +8,64 @@
 pragma solidity ^0.8.23;
 
 library CoinConstants {
+    /// @dev Constant used to increase precision during calculations
+    uint256 internal constant WAD = 1e18;
+
     /// @notice The maximum total supply
     /// @dev Set to 1 billion coins with 18 decimals
-    uint256 public constant MAX_TOTAL_SUPPLY = 1_000_000_000e18;
+    uint256 internal constant MAX_TOTAL_SUPPLY = 1_000_000_000e18;
+
+    /// @notice The total supply for creator coins (same as MAX_TOTAL_SUPPLY)
+    /// @dev 1 billion coins
+    uint256 internal constant TOTAL_SUPPLY = 1_000_000_000e18;
 
-    /// @notice The number of coins allocated to the liquidity pool
+    /// @notice The number of coins allocated to the liquidity pool for content coins
     /// @dev 990 million coins
-    uint256 public constant POOL_LAUNCH_SUPPLY = 990_000_000e18;
+    uint256 internal constant CONTENT_COIN_MARKET_SUPPLY = 990_000_000e18;
 
-    /// @notice The number of coins rewarded to the creator
+    /// @notice The number of coins allocated to the liquidity pool for creator coins
+    /// @dev 500 million coins
+    uint256 internal constant CREATOR_COIN_MARKET_SUPPLY = 500_000_000e18;
+
+    /// @notice The number of coins rewarded to the creator for content coins on launch
     /// @dev 10 million coins
-    uint256 public constant CREATOR_LAUNCH_REWARD = 10_000_000e18;
+    uint256 internal constant CONTENT_COIN_INITIAL_CREATOR_SUPPLY = TOTAL_SUPPLY - CONTENT_COIN_MARKET_SUPPLY;
+
+    /// @notice Creator coin vesting supply for creator
+    /// @dev 500 million coins
+    uint256 internal constant CREATOR_COIN_CREATOR_VESTING_SUPPLY = TOTAL_SUPPLY - CREATOR_COIN_MARKET_SUPPLY;
 
-    /// @notice The minimum order size allowed for trades
-    /// @dev Set to 0.0000001 ETH to prevent dust transactions
-    uint256 public constant MIN_ORDER_SIZE = 0.0000001 ether;
+    /// @notice Creator coin vesting duration
+    /// @dev 5 years with leap years accounted for
+    uint256 internal constant CREATOR_VESTING_DURATION = (5 * 365.25 days);
 
-    /// @notice The total fee percentage in basis points
-    /// @dev 100 basis points = 1%
-    uint256 public constant TOTAL_FEE_BPS = 100;
+    /// @notice The backing currency for creator coins
+    /// @dev ETH backing currency address
+    address internal constant CREATOR_COIN_CURRENCY = 0x1111111111166b7FE7bd91427724B487980aFc69;
 
-    /// @notice The percentage of the total fee allocated to creators
-    /// @dev 5000 basis points = 50% of TOTAL_FEE_BPS
-    uint256 public constant TOKEN_CREATOR_FEE_BPS = 5000;
+    /// @notice The LP fee
+    /// @dev 10000 basis points = 1%
+    uint24 internal constant LP_FEE_V4 = 10_000;
 
-    /// @notice The percentage of the total fee allocated to the protocol
-    /// @dev 2000 basis points = 20% of TOTAL_FEE_BPS
-    uint256 public constant PROTOCOL_FEE_BPS = 2000;
+    /// @notice The spacing for 1% pools
+    /// @dev 200 ticks
+    int24 internal constant TICK_SPACING = 200;
 
-    /// @notice The percentage of the total fee allocated to platform referrers
-    /// @dev 1500 basis points = 15% of TOTAL_FEE_BPS
-    uint256 public constant PLATFORM_REFERRER_FEE_BPS = 1500;
+    // Creator gets 62.5% of market rewards (0.50% of total 1% fee)
+    // Market rewards = 80% of total fee (0.80% of 1%)
+    uint256 internal constant CREATOR_REWARD_BPS = 6250;
 
-    /// @notice The percentage of the total fee allocated to trade referrers
-    /// @dev 1500 basis points = 15% of TOTAL_FEE_BPS
-    uint256 public constant TRADE_REFERRER_FEE_BPS = 1500;
+    // Platform referrer gets 25% of market rewards (0.20% of total 1% fee)
+    uint256 internal constant CREATE_REFERRAL_REWARD_BPS = 2500;
 
-    /// @notice The percentage of the LP fee allocated to creators
-    /// @dev 5000 basis points = 50% of the 1% LP FEE
-    uint256 public constant CREATOR_MARKET_REWARD_BPS = 5000;
+    // Trade referrer gets 5% of market rewards (0.04% of total 1% fee)
+    uint256 internal constant TRADE_REFERRAL_REWARD_BPS = 500;
 
-    /// @notice The percentage of the LP fee allocated to platform referrers
-    /// @dev 2500 basis points = 25% of the 1% LP FEE
-    uint256 public constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
+    // Doppler gets 1.25% of market rewards (0.01% of total 1% fee)
+    uint256 internal constant DOPPLER_REWARD_BPS = 125;
 
-    /// @notice The percentage of the LP fee allocated to the Doppler protocol
-    /// @dev 500 basis points = 5% of the 1% LP FEE
-    uint256 public constant DOPPLER_MARKET_REWARD_BPS = 500;
+    // LPs get 20% of total fee (0.20% of 1%)
+    uint256 internal constant LP_REWARD_BPS = 2000;
 
     int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = -777000;
     int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = 222000;

package/src/libs/CoinDopplerMultiCurve.sol

@@ -10,7 +10,7 @@ pragma solidity ^0.8.23;
 import {PoolConfiguration} from "../interfaces/ICoin.sol";
 import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
 import {LpPosition} from "../types/LpPosition.sol";
-import {MarketConstants} from "./MarketConstants.sol";
+import {CoinConstants} from "./CoinConstants.sol";
 import {FullMath} from "../utils/uniswap/FullMath.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {IDopplerErrors} from "../interfaces/IDopplerErrors.sol";
@@ -56,8 +56,8 @@ library CoinDopplerMultiCurve {
         uint256 totalDiscoverySupplyShare;
         uint256 totalDiscoveryPositions;
 
-        int24 boundryTickLower = DopplerMath.alignTickToTickSpacing(isCoinToken0, TickMath.MAX_TICK, MarketConstants.TICK_SPACING);
-        int24 boundryTickUpper = DopplerMath.alignTickToTickSpacing(isCoinToken0, TickMath.MIN_TICK, MarketConstants.TICK_SPACING);
+        int24 boundryTickLower = DopplerMath.alignTickToTickSpacing(isCoinToken0, TickMath.MAX_TICK, CoinConstants.TICK_SPACING);
+        int24 boundryTickUpper = DopplerMath.alignTickToTickSpacing(isCoinToken0, TickMath.MIN_TICK, CoinConstants.TICK_SPACING);
 
         // For each curve:
         for (uint256 i; i < numCurves; i++) {
@@ -69,8 +69,8 @@ library CoinDopplerMultiCurve {
             totalDiscoveryPositions += numDiscoveryPositions_[i];
             totalDiscoverySupplyShare += maxDiscoverySupplyShare_[i];
 
-            int24 currentTickLower = DopplerMath.alignTickToTickSpacing(isCoinToken0, tickLower_[i], MarketConstants.TICK_SPACING);
-            int24 currentTickUpper = DopplerMath.alignTickToTickSpacing(isCoinToken0, tickUpper_[i], MarketConstants.TICK_SPACING);
+            int24 currentTickLower = DopplerMath.alignTickToTickSpacing(isCoinToken0, tickLower_[i], CoinConstants.TICK_SPACING);
+            int24 currentTickUpper = DopplerMath.alignTickToTickSpacing(isCoinToken0, tickUpper_[i], CoinConstants.TICK_SPACING);
 
             require(currentTickLower < currentTickUpper, ConfigTickLowerMustBeLessThanTickUpper());
 
@@ -84,15 +84,15 @@ library CoinDopplerMultiCurve {
 
         require(boundryTickLower < boundryTickUpper, InvalidTickRangeMisordered(boundryTickLower, boundryTickUpper));
         require(totalDiscoveryPositions > 1 && totalDiscoveryPositions <= 200, IDopplerErrors.NumDiscoveryPositionsOutOfRange());
-        require(totalDiscoverySupplyShare < MarketConstants.WAD, IDopplerErrors.MaxShareToBeSoldExceeded(totalDiscoverySupplyShare, MarketConstants.WAD));
+        require(totalDiscoverySupplyShare < CoinConstants.WAD, IDopplerErrors.MaxShareToBeSoldExceeded(totalDiscoverySupplyShare, CoinConstants.WAD));
 
         sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? boundryTickLower : boundryTickUpper);
 
         poolConfiguration = PoolConfiguration({
             version: CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION,
             numPositions: uint16(totalDiscoveryPositions + 1), // Add one for the final tail position
-            fee: MarketConstants.LP_FEE_V4,
-            tickSpacing: MarketConstants.TICK_SPACING,
+            fee: CoinConstants.LP_FEE_V4,
+            tickSpacing: CoinConstants.TICK_SPACING,
             numDiscoveryPositions: numDiscoveryPositions_,
             tickLower: tickLower_,
             tickUpper: tickUpper_,
@@ -113,12 +113,12 @@ library CoinDopplerMultiCurve {
         uint256 numCurves = poolConfiguration.tickLower.length;
 
         for (uint256 i; i < numCurves; i++) {
-            uint256 curveSupply = FullMath.mulDiv(totalSupply, poolConfiguration.maxDiscoverySupplyShare[i], MarketConstants.WAD);
+            uint256 curveSupply = FullMath.mulDiv(totalSupply, poolConfiguration.maxDiscoverySupplyShare[i], CoinConstants.WAD);
 
             (positions, curveSupply) = DopplerMath.calculateLogNormalDistribution(
                 poolConfiguration.tickLower[i],
                 poolConfiguration.tickUpper[i],
-                MarketConstants.TICK_SPACING,
+                CoinConstants.TICK_SPACING,
                 isCoinToken0,
                 curveSupply,
                 poolConfiguration.numDiscoveryPositions[i],
@@ -138,7 +138,7 @@ library CoinDopplerMultiCurve {
             poolConfiguration.tickUpper[numCurves - 1],
             isCoinToken0,
             tailSupply,
-            MarketConstants.TICK_SPACING
+            CoinConstants.TICK_SPACING
         );
     }
 }

package/src/libs/CoinRewardsV4.sol

@@ -29,29 +29,15 @@ import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
 import {IHasSwapPath} from "../interfaces/ICoin.sol";
 import {V4Liquidity} from "./V4Liquidity.sol";
 import {UniV4SwapToCurrency} from "./UniV4SwapToCurrency.sol";
+import {ICreatorCoinHook} from "../interfaces/ICreatorCoinHook.sol";
+import {IHasCoinType} from "../interfaces/ICoin.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {ICreatorCoin} from "../interfaces/ICreatorCoin.sol";
+import {CoinConstants} from "./CoinConstants.sol";
 
 library CoinRewardsV4 {
     using SafeERC20 for IERC20;
 
-    // creator gets 50% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant CREATOR_REWARD_BPS = 5000;
-
-    // create referrer gets 15% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 1500;
-
-    // trade referrer gets 10% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 1500;
-
-    // doppler gets 5% of the market rewards
-    // market rewards are 2/3 of the total fee
-    uint256 public constant DOPPLER_REWARD_BPS = 500;
-
-    // LPs get 1/3 of the total fee
-    uint256 public constant LP_REWARD_BPS = 3333;
-
     function getTradeReferral(bytes calldata hookData) internal pure returns (address) {
         return hookData.length >= 20 ? abi.decode(hookData, (address)) : address(0);
     }
@@ -82,13 +68,16 @@ library CoinRewardsV4 {
 
     /// @dev Computes the LP reward and remaining amount for market rewards from the total amount
     function computeLpReward(uint128 totalBackingAmount) internal pure returns (uint128 lpRewardAmount) {
-        lpRewardAmount = uint128(calculateReward(uint256(totalBackingAmount), LP_REWARD_BPS));
+        lpRewardAmount = uint128(calculateReward(uint256(totalBackingAmount), CoinConstants.LP_REWARD_BPS));
     }
 
     function convertDeltaToPositiveUint128(int256 delta) internal pure returns (uint128) {
         if (delta < 0) {
             revert SafeCast.SafeCastOverflow();
         }
+        if (delta > int256(uint256(type(uint128).max))) {
+            revert SafeCast.SafeCastOverflow();
+        }
         return uint128(uint256(delta));
     }
 
@@ -180,7 +169,14 @@ library CoinRewardsV4 {
     /// @param fees The total amount of fees collected to be distributed
     /// @param coin The coin contract instance that implements IHasRewardsRecipients to get recipient addresses
     /// @param tradeReferrer The address of the trade referrer who should receive trade referral rewards (can be zero address)
-    function distributeMarketRewards(Currency currency, uint128 fees, IHasRewardsRecipients coin, address tradeReferrer) internal {
+    /// @param coinType The type of coin (Creator or Content) which affects reward distribution percentages
+    function distributeMarketRewards(
+        Currency currency,
+        uint128 fees,
+        IHasRewardsRecipients coin,
+        address tradeReferrer,
+        IHasCoinType.CoinType coinType
+    ) internal {
         address payoutRecipient = coin.payoutRecipient();
         address platformReferrer = coin.platformReferrer();
         address protocolRewardRecipient = coin.protocolRewardRecipient();
@@ -219,6 +215,17 @@ library CoinRewardsV4 {
             doppler,
             marketRewards
         );
+
+        if (coinType == IHasCoinType.CoinType.Creator) {
+            emit ICreatorCoinHook.CreatorCoinRewards(
+                address(coin),
+                Currency.unwrap(currency),
+                payoutRecipient,
+                protocolRewardRecipient,
+                rewards.creatorAmount,
+                rewards.protocolAmount
+            );
+        }
     }
 
     struct MarketRewards {
@@ -240,26 +247,30 @@ library CoinRewardsV4 {
     ) internal returns (MarketRewards memory rewards) {
         rewards = _computeMarketRewards(fee, tradeReferral != address(0), platformReferrer != address(0));
 
-        if (platformReferrer != address(0)) {
-            _transferCurrency(currency, rewards.platformReferrerAmount, platformReferrer);
-        }
-        if (tradeReferral != address(0)) {
-            _transferCurrency(currency, rewards.tradeReferrerAmount, tradeReferral);
-        }
-        _transferCurrency(currency, rewards.creatorAmount, payoutRecipient);
-        _transferCurrency(currency, rewards.dopplerAmount, doppler);
-        _transferCurrency(currency, rewards.protocolAmount, protocolRewardRecipient);
+        // Notes on ETH transfer fallback behavior:
+        // - If the platform referrer is immutable; if it is set to an address that cannot receive ETH, it can brick swaps on the coin, as they would revert.
+        // - Both the creator recipient and trade referral are changeable, the former via updating the payout recipient on the coin, and the latter via updating the trade referrer argument when doing a swap;
+        // therefore we do not need to worry about permanently bricking swaps, and don't need a backup recipient.
+        _transferCurrency(currency, rewards.platformReferrerAmount, platformReferrer, protocolRewardRecipient);
+        _transferCurrency(currency, rewards.tradeReferrerAmount, tradeReferral, address(0));
+        _transferCurrency(currency, rewards.creatorAmount, payoutRecipient, address(0));
+        _transferCurrency(currency, rewards.dopplerAmount, doppler, protocolRewardRecipient);
+        _transferCurrency(currency, rewards.protocolAmount, protocolRewardRecipient, address(0));
     }
 
-    function _transferCurrency(Currency currency, uint256 amount, address to) internal {
-        if (amount == 0) {
+    function _transferCurrency(Currency currency, uint256 amount, address to, address backupRecipient) internal {
+        if (amount == 0 || to == address(0)) {
             return;
         }
 
         if (currency.isAddressZero()) {
             (bool success, ) = payable(to).call{value: amount}("");
             if (!success) {
-                revert ICoin.EthTransferFailed();
+                if (backupRecipient == address(0)) {
+                    revert ICoin.EthTransferFailed();
+                } else {
+                    _transferCurrency(currency, amount, backupRecipient, address(0));
+                }
             }
         } else {
             IERC20(Currency.unwrap(currency)).safeTransfer(to, amount);
@@ -272,14 +283,34 @@ library CoinRewardsV4 {
         }
 
         uint256 totalAmount = uint256(fee);
-        rewards.platformReferrerAmount = hasCreateReferral ? calculateReward(totalAmount, CREATE_REFERRAL_REWARD_BPS) : 0;
-        rewards.tradeReferrerAmount = hasTradeReferral ? calculateReward(totalAmount, TRADE_REFERRAL_REWARD_BPS) : 0;
-        rewards.creatorAmount = calculateReward(totalAmount, CREATOR_REWARD_BPS);
-        rewards.dopplerAmount = calculateReward(totalAmount, DOPPLER_REWARD_BPS);
+        rewards.platformReferrerAmount = hasCreateReferral ? calculateReward(totalAmount, CoinConstants.CREATE_REFERRAL_REWARD_BPS) : 0;
+        rewards.tradeReferrerAmount = hasTradeReferral ? calculateReward(totalAmount, CoinConstants.TRADE_REFERRAL_REWARD_BPS) : 0;
+        rewards.creatorAmount = calculateReward(totalAmount, CoinConstants.CREATOR_REWARD_BPS);
+        rewards.dopplerAmount = calculateReward(totalAmount, CoinConstants.DOPPLER_REWARD_BPS);
         rewards.protocolAmount = totalAmount - rewards.platformReferrerAmount - rewards.tradeReferrerAmount - rewards.creatorAmount - rewards.dopplerAmount;
     }
 
     function calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
         return (amount * bps) / 10_000;
     }
+
+    function getCoinType(IHasRewardsRecipients coin) internal view returns (IHasCoinType.CoinType) {
+        // first check if the coin supports the IHasCoinType interface - if it does, we can use that
+        if (IERC165(address(coin)).supportsInterface(type(IHasCoinType).interfaceId)) {
+            return IHasCoinType(address(coin)).coinType();
+        }
+
+        // see if its a legacy creator coin
+        return isLegacyCreatorCoin(coin) ? IHasCoinType.CoinType.Creator : IHasCoinType.CoinType.Content;
+    }
+
+    function isLegacyCreatorCoin(IHasRewardsRecipients coin) internal view returns (bool) {
+        // try to call the method `getClaimableAmount` on the legacy creator coin, if it succeeds, then it is a legacy creator coin,
+        // otherwise we can assume it is a content coin
+        try ICreatorCoin(address(coin)).getClaimableAmount() returns (uint256) {
+            return true;
+        } catch {
+            return false;
+        }
+    }
 }

package/src/libs/CoinSetup.sol

@@ -11,12 +11,11 @@ import {PoolConfigurationV4} from "../interfaces/ICoin.sol";
 import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
 import {ICoin} from "../interfaces/ICoin.sol";
 import {CoinCommon} from "./CoinCommon.sol";
-import {MarketConstants} from "./MarketConstants.sol";
+import {CoinConstants} from "./CoinConstants.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {IPoolManager, PoolKey, Currency, IHooks} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol";
 import {IPositionManager} from "@uniswap/v4-periphery/src/interfaces/IPositionManager.sol";
-import {MarketConstants} from "./MarketConstants.sol";
 import {LpPosition} from "../types/LpPosition.sol";
 import {CoinDopplerMultiCurve, PoolConfiguration} from "./CoinDopplerMultiCurve.sol";
 
@@ -37,13 +36,7 @@ library CoinSetup {
         Currency currency0 = isCoinToken0 ? Currency.wrap(coin) : Currency.wrap(currency);
         Currency currency1 = isCoinToken0 ? Currency.wrap(currency) : Currency.wrap(coin);
 
-        poolKey = PoolKey({
-            currency0: currency0,
-            currency1: currency1,
-            fee: MarketConstants.LP_FEE_V4,
-            tickSpacing: MarketConstants.TICK_SPACING,
-            hooks: hooks
-        });
+        poolKey = PoolKey({currency0: currency0, currency1: currency1, fee: CoinConstants.LP_FEE_V4, tickSpacing: CoinConstants.TICK_SPACING, hooks: hooks});
     }
 
     function setupPoolWithVersion(

package/src/libs/DopplerMath.sol

@@ -13,7 +13,7 @@ import {FullMath} from "../utils/uniswap/FullMath.sol";
 import {SqrtPriceMath} from "../utils/uniswap/SqrtPriceMath.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
 import {LpPosition} from "../types/LpPosition.sol";
-import {MarketConstants} from "./MarketConstants.sol";
+import {CoinConstants} from "./CoinConstants.sol";
 
 /// @author Whetstone Research
 /// @notice Calculates liquidity provisioning with Uniswap v3
@@ -54,7 +54,7 @@ library DopplerMath {
         int24 spread = tickUpper - tickLower;
 
         uint160 farSqrtPriceX96 = TickMath.getSqrtPriceAtTick(farTick);
-        uint256 amountPerPosition = FullMath.mulDiv(discoverySupply, MarketConstants.WAD, totalPositions * MarketConstants.WAD);
+        uint256 amountPerPosition = FullMath.mulDiv(discoverySupply, CoinConstants.WAD, totalPositions * CoinConstants.WAD);
         uint256 totalAssetsSold;
 
         for (uint256 i; i < totalPositions; i++) {

package/src/libs/HooksDeployment.sol

@@ -9,8 +9,7 @@ pragma solidity ^0.8.23;
 
 import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
 import {Vm} from "forge-std/Vm.sol";
-import {ContentCoinHook} from "../hooks/ContentCoinHook.sol";
-import {CreatorCoinHook} from "../hooks/CreatorCoinHook.sol";
+import {ZoraV4CoinHook} from "../hooks/ZoraV4CoinHook.sol";
 import {HookMiner} from "@uniswap/v4-periphery/src/utils/HookMiner.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
@@ -83,26 +82,14 @@ library HooksDeployment {
         }
     }
 
-    function mineForCreatorCoinSalt(
+    function mineForCoinSalt(
         address deployer,
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
         address upgradeGate
     ) internal returns (address hookAddress, bytes32 salt) {
-        bytes memory hookCreationCode = creatorCoinHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
-        (salt, ) = mineAndCacheSalt(deployer, hookCreationCode);
-        hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, salt, hookCreationCode);
-    }
-
-    function mineForContentCoinSalt(
-        address deployer,
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal returns (address hookAddress, bytes32 salt) {
-        bytes memory hookCreationCode = contentCoinCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        bytes memory hookCreationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
         (salt, ) = mineAndCacheSalt(deployer, hookCreationCode);
         hookAddress = HookMinerWithCreationCodeArgs.deterministicHookAddress(deployer, salt, hookCreationCode);
     }
@@ -141,7 +128,7 @@ library HooksDeployment {
         isDeployed = hookAddress.code.length > 0;
     }
 
-    function contentCoinConstructorArgs(
+    function hookConstructorArgs(
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
@@ -150,82 +137,43 @@ library HooksDeployment {
         return abi.encode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
     }
 
-    function contentCoinCreationCode(
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal pure returns (bytes memory) {
-        return
-            abi.encodePacked(
-                type(ContentCoinHook).creationCode,
-                contentCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
-            );
-    }
-
-    function creatorCoinCreationCode(
+    function makeHookCreationCode(
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
         address upgradeGate
     ) internal pure returns (bytes memory) {
-        return
-            abi.encodePacked(
-                type(CreatorCoinHook).creationCode,
-                creatorCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
-            );
+        return abi.encodePacked(type(ZoraV4CoinHook).creationCode, hookConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate));
     }
 
     /// @notice Deploys or returns existing ContentCoinHook using deterministic deployment.  Ensures that if a hooks is already
     /// deployed with the provided salt, it will be returned.
-    function deployContentCoinHook(
+    function deployZoraV4CoinHook(
         address poolManager,
         address coinVersionLookup,
         address[] memory trustedMessageSenders,
         address upgradeGate,
         bytes32 salt
     ) internal returns (IHooks hook) {
-        bytes memory hookCreationCode = contentCoinCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
-        return deployHookWithSalt(hookCreationCode, salt);
-    }
-
-    function creatorCoinConstructorArgs(
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal pure returns (bytes memory) {
-        return abi.encode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
-    }
-
-    function creatorCoinHookCreationCode(
-        address poolManager,
-        address coinVersionLookup,
-        address[] memory trustedMessageSenders,
-        address upgradeGate
-    ) internal pure returns (bytes memory) {
-        return
-            abi.encodePacked(
-                type(CreatorCoinHook).creationCode,
-                creatorCoinConstructorArgs(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate)
-            );
+        bytes memory creationCode = makeHookCreationCode(poolManager, coinVersionLookup, trustedMessageSenders, upgradeGate);
+        return deployHookWithSalt(creationCode, salt);
     }
 
     address constant FOUNDRY_SCRIPT_ADDRESS = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
 
     function deployHookWithExistingOrNewSalt(
         address deployer,
-        bytes memory hookCreationCode,
+        bytes memory _hookCreationCode,
         bytes32 salt
     ) internal returns (IHooks hook, bytes32 resultingSalt) {
-        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, hookCreationCode, salt);
+        (bool isDeployed, address existingHookAddress) = hooksIsDeployed(deployer, _hookCreationCode, salt);
 
         if (isDeployed) {
             hook = IHooks(existingHookAddress);
             resultingSalt = salt;
         } else {
-            (, resultingSalt) = mineForSalt(deployer, hookCreationCode);
-            hook = IHooks(Create2.deploy(0, resultingSalt, hookCreationCode));
+            (, resultingSalt) = mineForSalt(deployer, _hookCreationCode);
+            hook = IHooks(Create2.deploy(0, resultingSalt, _hookCreationCode));
         }
     }
 }