@zoralabs/coins 2.1.2 → 2.3.0

package/src/deployment/CoinsDeployerBase.sol

@@ -37,12 +37,12 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         // hooks
         address buySupplyWithSwapRouterHook;
         address zoraV4CoinHook;
-        address creatorCoinHook;
         address hookUpgradeGate;
         // Hook deployment salt (for deterministic deployment)
         bytes32 zoraV4CoinHookSalt;
-        bytes32 creatorCoinHookSalt;
         bool isDev;
+        // Hook registry
+        address zoraHookRegistry;
     }
 
     function addressesFile() internal view returns (string memory) {
@@ -67,9 +67,8 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         vm.serializeAddress(objectKey, "ZORA_V4_COIN_HOOK", deployment.zoraV4CoinHook);
         vm.serializeBytes32(objectKey, "ZORA_V4_COIN_HOOK_SALT", deployment.zoraV4CoinHookSalt);
         vm.serializeAddress(objectKey, "CREATOR_COIN_IMPL", deployment.creatorCoinImpl);
-        vm.serializeAddress(objectKey, "CREATOR_COIN_HOOK", deployment.creatorCoinHook);
-        vm.serializeBytes32(objectKey, "CREATOR_COIN_HOOK_SALT", deployment.creatorCoinHookSalt);
         vm.serializeAddress(objectKey, "HOOK_UPGRADE_GATE", deployment.hookUpgradeGate);
+        vm.serializeAddress(objectKey, "ZORA_HOOK_REGISTRY", deployment.zoraHookRegistry);
         string memory result = vm.serializeAddress(objectKey, "COIN_V4_IMPL", deployment.coinV4Impl);
 
         vm.writeJson(result, addressesFile(deployment.isDev));
@@ -96,12 +95,11 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         deployment.zoraV4CoinHook = readAddressOrDefaultToZero(json, "ZORA_V4_COIN_HOOK");
         deployment.zoraV4CoinHookSalt = readBytes32OrDefaultToZero(json, "ZORA_V4_COIN_HOOK_SALT");
         deployment.creatorCoinImpl = readAddressOrDefaultToZero(json, "CREATOR_COIN_IMPL");
-        deployment.creatorCoinHook = readAddressOrDefaultToZero(json, "CREATOR_COIN_HOOK");
-        deployment.creatorCoinHookSalt = readBytes32OrDefaultToZero(json, "CREATOR_COIN_HOOK_SALT");
         deployment.hookUpgradeGate = readAddressOrDefaultToZero(json, "HOOK_UPGRADE_GATE");
+        deployment.zoraHookRegistry = readAddressOrDefaultToZero(json, "ZORA_HOOK_REGISTRY");
     }
 
-    function deployCoinV4Impl(address zoraV4CoinHook) internal returns (ContentCoin) {
+    function deployCoinV4Impl() internal returns (ContentCoin) {
         return
             new ContentCoin({
                 protocolRewardRecipient_: getZoraRecipient(),
@@ -111,29 +109,18 @@ contract CoinsDeployerBase is ProxyDeployerScript {
             });
     }
 
-    function deployCreatorCoinImpl(address creatorCoinHook) internal returns (CreatorCoin) {
+    function deployCreatorCoinImpl() internal returns (CreatorCoin) {
         return
             new CreatorCoin({
-                _protocolRewardRecipient: getZoraRecipient(),
-                _protocolRewards: PROTOCOL_REWARDS,
-                _poolManager: IPoolManager(getUniswapV4PoolManager()),
-                _airlock: getDopplerAirlock()
+                protocolRewardRecipient_: getZoraRecipient(),
+                protocolRewards_: PROTOCOL_REWARDS,
+                poolManager_: IPoolManager(getUniswapV4PoolManager()),
+                airlock_: getDopplerAirlock()
             });
     }
 
-    function deployZoraFactoryImpl(
-        address _coinV4Impl,
-        address _creatorCoinImpl,
-        address _contentCoinHook,
-        address _creatorCoinHook
-    ) internal returns (ZoraFactoryImpl) {
-        return
-            new ZoraFactoryImpl({
-                _coinV4Impl: _coinV4Impl,
-                _creatorCoinImpl: _creatorCoinImpl,
-                _contentCoinHook: _contentCoinHook,
-                _creatorCoinHook: _creatorCoinHook
-            });
+    function deployZoraFactoryImpl(address coinV4Impl_, address creatorCoinImpl_, address hook_, address zoraHookRegistry_) internal returns (ZoraFactoryImpl) {
+        return new ZoraFactoryImpl({coinV4Impl_: coinV4Impl_, creatorCoinImpl_: creatorCoinImpl_, hook_: hook_, zoraHookRegistry_: zoraHookRegistry_});
     }
 
     // function deployBuySupplyWithSwapRouterHook(CoinsDeployment memory deployment) internal returns (BuySupplyWithSwapRouterHook) {
@@ -151,11 +138,11 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         return deployment;
     }
 
-    function deployContentCoinHook(CoinsDeployment memory deployment) internal returns (IHooks hook, bytes32 salt) {
+    function deployZoraV4CoinHook(CoinsDeployment memory deployment) internal returns (IHooks hook, bytes32 salt) {
         return
             HooksDeployment.deployHookWithExistingOrNewSalt(
                 HooksDeployment.FOUNDRY_SCRIPT_ADDRESS,
-                HooksDeployment.contentCoinCreationCode(
+                HooksDeployment.makeHookCreationCode(
                     getUniswapV4PoolManager(),
                     deployment.zoraFactory,
                     getDefaultTrustedMessageSenders(),
@@ -165,20 +152,6 @@ contract CoinsDeployerBase is ProxyDeployerScript {
             );
     }
 
-    function deployCreatorCoinHook(CoinsDeployment memory deployment) internal returns (IHooks hook, bytes32 salt) {
-        return
-            HooksDeployment.deployHookWithExistingOrNewSalt(
-                HooksDeployment.FOUNDRY_SCRIPT_ADDRESS,
-                HooksDeployment.creatorCoinHookCreationCode(
-                    getUniswapV4PoolManager(),
-                    deployment.zoraFactory,
-                    getDefaultTrustedMessageSenders(),
-                    deployment.hookUpgradeGate
-                ),
-                deployment.creatorCoinHookSalt
-            );
-    }
-
     function getDefaultTrustedMessageSenders() internal view returns (address[] memory) {
         address[] memory trustedMessageSenders = new address[](2);
         trustedMessageSenders[0] = getUniswapUniversalRouter();
@@ -190,10 +163,10 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         return
             address(
                 deployZoraFactoryImpl({
-                    _coinV4Impl: deployment.coinV4Impl,
-                    _creatorCoinImpl: deployment.creatorCoinImpl,
-                    _contentCoinHook: deployment.zoraV4CoinHook,
-                    _creatorCoinHook: deployment.creatorCoinHook
+                    coinV4Impl_: deployment.coinV4Impl,
+                    creatorCoinImpl_: deployment.creatorCoinImpl,
+                    hook_: deployment.zoraV4CoinHook,
+                    zoraHookRegistry_: deployment.zoraHookRegistry
                 })
             );
     }
@@ -203,17 +176,12 @@ contract CoinsDeployerBase is ProxyDeployerScript {
 
         // Deploy hook first, then use its address for coin v4 impl
         console.log("deploying content coin hook");
-        (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployContentCoinHook(deployment);
+        (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployZoraV4CoinHook(deployment);
         deployment.zoraV4CoinHook = address(zoraV4CoinHook);
         deployment.zoraV4CoinHookSalt = usedSalt;
 
-        console.log("deploying creator coin hook");
-        (IHooks creatorCoinHook, bytes32 usedCreatorCoinHookSalt) = deployCreatorCoinHook(deployment);
-        deployment.creatorCoinHook = address(creatorCoinHook);
-        deployment.creatorCoinHookSalt = usedCreatorCoinHookSalt;
-
-        deployment.coinV4Impl = address(deployCoinV4Impl(deployment.zoraV4CoinHook));
-        deployment.creatorCoinImpl = address(deployCreatorCoinImpl(deployment.creatorCoinHook));
+        deployment.coinV4Impl = address(deployCoinV4Impl());
+        deployment.creatorCoinImpl = address(deployCreatorCoinImpl());
         deployment.zoraFactoryImpl = deployFactoryImpl(deployment);
         deployment.coinVersion = IVersionedContract(deployment.coinV4Impl).contractVersion();
         // deployment.buySupplyWithSwapRouterHook = address(deployBuySupplyWithSwapRouterHook(deployment));
@@ -223,14 +191,10 @@ contract CoinsDeployerBase is ProxyDeployerScript {
 
     function deployHooks(CoinsDeployment memory deployment) internal returns (CoinsDeployment memory) {
         // Deploy hook first, then use its address for coin v4 impl
-        (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployContentCoinHook(deployment);
+        (IHooks zoraV4CoinHook, bytes32 usedSalt) = deployZoraV4CoinHook(deployment);
         deployment.zoraV4CoinHook = address(zoraV4CoinHook);
         deployment.zoraV4CoinHookSalt = usedSalt;
 
-        (IHooks creatorCoinHook, bytes32 usedCreatorCoinHookSalt) = deployCreatorCoinHook(deployment);
-        deployment.creatorCoinHook = address(creatorCoinHook);
-        deployment.creatorCoinHookSalt = usedCreatorCoinHookSalt;
-
         deployment.zoraFactoryImpl = deployFactoryImpl(deployment);
 
         return deployment;
@@ -284,6 +248,8 @@ contract CoinsDeployerBase is ProxyDeployerScript {
         ZoraFactoryImpl(deployment.zoraFactory).initialize(owner);
 
         saveDeployment(deployment);
+
+        return ZoraFactory(payable(deployment.zoraFactory));
     }
 
     function printUpgradeFactoryCommand(CoinsDeployment memory deployment) internal view {

package/src/hook-registry/ZoraHookRegistry.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
+import {MultiOwnable} from "../utils/MultiOwnable.sol";
+import {IZoraHookRegistry} from "../interfaces/IZoraHookRegistry.sol";
+
+/// @title Zora Hook Registry
+/// @notice A registry of Zora hook contracts for Uniswap V4
+contract ZoraHookRegistry is IZoraHookRegistry, MultiOwnable {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    /// @dev The set of registered hook addresses
+    EnumerableSet.AddressSet internal registeredHooks;
+
+    /// @dev The tag for each hook
+    mapping(address hook => string tag) internal hookTags;
+
+    /// @notice Constructor for deployment pathway
+    /// @dev This contract needs to be atomically initialized, otherwise it is unsafe to deploy.
+    /// @dev Initial owners need to be automatically set by the deployer contract.
+    /// @dev The initial owners is not a part of the constructor() to allow for multichain deterministic addresses.
+    constructor() {}
+
+    /// @notice Initializes the registry with initial owners
+    function initialize(address[] memory initialOwners) external initializer {
+        __MultiOwnable_init(initialOwners);
+    }
+
+    /// @notice Returns whether a hook is currently registered
+    function isRegisteredHook(address hook) external view returns (bool) {
+        return registeredHooks.contains(hook);
+    }
+
+    /// @notice Returns all registered hooks
+    function getHooks() external view returns (ZoraHook[] memory) {
+        uint256 numHooks = registeredHooks.length();
+
+        ZoraHook[] memory hooks = new ZoraHook[](numHooks);
+
+        for (uint256 i; i < numHooks; i++) {
+            address hook = registeredHooks.at(i);
+
+            hooks[i] = ZoraHook({hook: hook, tag: getHookTag(hook), version: getHookVersion(hook)});
+        }
+
+        return hooks;
+    }
+
+    /// @notice Returns all registered hook addresses
+    function getHookAddresses() external view returns (address[] memory) {
+        return registeredHooks.values();
+    }
+
+    /// @notice Returns the tag for a hook
+    function getHookTag(address hook) public view returns (string memory) {
+        return hookTags[hook];
+    }
+
+    /// @notice Returns the contract version for a hook if it exists
+    function getHookVersion(address hook) public pure returns (string memory version) {
+        try IVersionedContract(hook).contractVersion() returns (string memory _version) {
+            version = _version;
+        } catch {}
+    }
+
+    /// @notice Adds hooks to the registry
+    function registerHooks(address[] calldata hooks, string[] calldata tags) external onlyOwner {
+        require(hooks.length == tags.length, ArrayLengthMismatch());
+
+        for (uint256 i; i < hooks.length; i++) {
+            if (registeredHooks.add(hooks[i])) {
+                hookTags[hooks[i]] = tags[i];
+
+                emit ZoraHookRegistered(hooks[i], tags[i], getHookVersion(hooks[i]));
+            }
+        }
+    }
+
+    /// @notice Removes hooks from the registry
+    function removeHooks(address[] calldata hooks) external onlyOwner {
+        for (uint256 i; i < hooks.length; i++) {
+            if (registeredHooks.remove(hooks[i])) {
+                emit ZoraHookRemoved(hooks[i], hookTags[hooks[i]], getHookVersion(hooks[i]));
+
+                delete hookTags[hooks[i]];
+            }
+        }
+    }
+}

package/src/hooks/{BaseZoraV4CoinHook.sol → ZoraV4CoinHook.sol}

@@ -31,12 +31,14 @@ import {IUpgradeableV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
 import {IHooksUpgradeGate} from "../interfaces/IHooksUpgradeGate.sol";
 import {MultiOwnable} from "../utils/MultiOwnable.sol";
 import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
-import {IUpgradeableDestinationV4Hook} from "../interfaces/IUpgradeableV4Hook.sol";
+import {IUpgradeableDestinationV4Hook, IUpgradeableDestinationV4HookWithUpdateableFee} from "../interfaces/IUpgradeableV4Hook.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {BurnedPosition} from "../interfaces/IUpgradeableV4Hook.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {ContractVersionBase, IVersionedContract} from "../version/ContractVersionBase.sol";
+import {IHasCoinType} from "../interfaces/ICoin.sol";
+import {CoinConstants} from "../libs/CoinConstants.sol";
 
 /// @title ZoraV4CoinHook
 /// @notice Uniswap V4 hook that automatically handles fee collection and reward distributions on every swap,
@@ -48,7 +50,14 @@ import {ContractVersionBase, IVersionedContract} from "../version/ContractVersio
 ///      2. Swaps collected fees to the backing currency through multi-hop paths
 ///      3. Distributes converted fees as rewards
 /// @author oveddan
-abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4CoinHook, ERC165, IUpgradeableDestinationV4Hook {
+contract ZoraV4CoinHook is
+    BaseHook,
+    ContractVersionBase,
+    IZoraV4CoinHook,
+    ERC165,
+    IUpgradeableDestinationV4Hook,
+    IUpgradeableDestinationV4HookWithUpdateableFee
+{
     using BalanceDeltaLibrary for BalanceDelta;
 
     /// @notice Mapping of trusted message senders - these are addresses that are trusted to provide a
@@ -64,8 +73,6 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
     /// @notice The upgrade gate contract - used to verify allowed upgrade paths
     IHooksUpgradeGate internal immutable upgradeGate;
 
-    uint256 internal immutable totalSupplyForPositions;
-
     /// @notice The constructor for the ZoraV4CoinHook.
     /// @param poolManager_ The Uniswap V4 pool manager
     /// @param coinVersionLookup_ The coin version lookup contract - used to determine if an address is a coin and what version it is.
@@ -75,8 +82,7 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
         IPoolManager poolManager_,
         IDeployedCoinVersionLookup coinVersionLookup_,
         address[] memory trustedMessageSenders_,
-        IHooksUpgradeGate upgradeGate_,
-        uint256 totalSupplyForPositions_
+        IHooksUpgradeGate upgradeGate_
     ) BaseHook(poolManager_) {
         require(address(coinVersionLookup_) != address(0), CoinVersionLookupCannotBeZeroAddress());
 
@@ -84,7 +90,6 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
 
         coinVersionLookup = coinVersionLookup_;
         upgradeGate = upgradeGate_;
-        totalSupplyForPositions = totalSupplyForPositions_;
 
         for (uint256 i = 0; i < trustedMessageSenders_.length; i++) {
             trustedMessageSender[trustedMessageSenders_[i]] = true;
@@ -133,6 +138,7 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
         return
             super.supportsInterface(interfaceId) ||
             interfaceId == type(IUpgradeableDestinationV4Hook).interfaceId ||
+            interfaceId == type(IUpgradeableDestinationV4HookWithUpdateableFee).interfaceId ||
             interfaceId == type(IVersionedContract).interfaceId;
     }
 
@@ -140,10 +146,18 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
     /// @param coin The coin address.
     /// @param key The pool key for the coin.
     /// @return positions The contract-created liquidity positions the positions for the coin's pool.
-    function _generatePositions(ICoin coin, PoolKey memory key) internal view returns (LpPosition[] memory positions) {
+    function _generatePositions(ICoin coin, PoolKey memory key) internal view returns (LpPosition[] memory) {
         bool isCoinToken0 = Currency.unwrap(key.currency0) == address(coin);
 
-        positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, coin.getPoolConfiguration(), totalSupplyForPositions);
+        LpPosition[] memory calculatedPositions = CoinDopplerMultiCurve.calculatePositions(
+            isCoinToken0,
+            coin.getPoolConfiguration(),
+            coin.totalSupplyForPositions()
+        );
+
+        // sometimes the calculated positions have liquidity added in duplicated positions.   So here we dedupe them
+        // to save on gas in future swaps.
+        return V4Liquidity.dedupePositions(calculatedPositions);
     }
 
     /// @notice Internal fn called when a pool is initialized.
@@ -171,17 +185,50 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
     }
 
     /// @inheritdoc IUpgradeableDestinationV4Hook
+    /// @dev left for backward compatibility for migrating from hooks that dont support
+    /// updating the fee
     function initializeFromMigration(
         PoolKey calldata poolKey,
         address coin,
         uint160 sqrtPriceX96,
         BurnedPosition[] calldata migratedLiquidity,
-        bytes calldata
+        bytes calldata additionalData
     ) external {
+        // keep the existing fee and tick spacing.
+        uint24 fee = poolKey.fee;
+        int24 tickSpacing = poolKey.tickSpacing;
+
+        _initializeFromMigration(poolKey, coin, sqrtPriceX96, migratedLiquidity, additionalData, fee, tickSpacing);
+    }
+
+    /// @inheritdoc IUpgradeableDestinationV4HookWithUpdateableFee
+    function initializeFromMigrationWithUpdateableFee(
+        PoolKey calldata poolKey,
+        address coin,
+        uint160 sqrtPriceX96,
+        BurnedPosition[] calldata migratedLiquidity,
+        bytes calldata additionalData
+    ) external returns (uint24 fee, int24 tickSpacing) {
+        // update the fee to the current one.
+        fee = CoinConstants.LP_FEE_V4;
+        tickSpacing = CoinConstants.TICK_SPACING;
+
+        _initializeFromMigration(poolKey, coin, sqrtPriceX96, migratedLiquidity, additionalData, fee, tickSpacing);
+    }
+
+    function _initializeFromMigration(
+        PoolKey calldata poolKey,
+        address coin,
+        uint160 sqrtPriceX96,
+        BurnedPosition[] calldata migratedLiquidity,
+        bytes calldata,
+        uint24 fee,
+        int24 tickSpacing
+    ) internal {
         address oldHook = msg.sender;
         address newHook = address(this);
 
-        // Verify that the caller (new hook) is authorized to perform this migration
+        // Verify that the caller (old hook) is authorized to perform this migration
         // Only registered upgrade paths in the upgrade gate are allowed to migrate liquidity
         if (!upgradeGate.isRegisteredUpgradePath(oldHook, newHook)) {
             revert IUpgradeableV4Hook.UpgradePathNotRegistered(oldHook, newHook);
@@ -192,8 +239,8 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
         PoolKey memory newKey = PoolKey({
             currency0: poolKey.currency0,
             currency1: poolKey.currency1,
-            fee: poolKey.fee,
-            tickSpacing: poolKey.tickSpacing,
+            fee: fee,
+            tickSpacing: tickSpacing,
             hooks: IHooks(newHook)
         });
 
@@ -336,9 +383,17 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
     }
 
     /// @dev Internal fn to allow for overriding market reward distribution logic
-    function _distributeMarketRewards(Currency currency, uint128 fees, IHasRewardsRecipients coin, address tradeReferrer) internal virtual;
+    function _distributeMarketRewards(Currency currency, uint128 fees, IHasRewardsRecipients coin, address tradeReferrer) internal virtual {
+        // get rewards distribution methodology from the coin
+        IHasCoinType.CoinType coinType = _getCoinType(coin);
+        CoinRewardsV4.distributeMarketRewards(currency, fees, coin, tradeReferrer, coinType);
+    }
 
-    /// @notice Internal fn called when the PoolManager is unlocked.  Used to mint initial liquidity positions.
+    function _getCoinType(IHasRewardsRecipients coin) internal view returns (IHasCoinType.CoinType) {
+        return CoinRewardsV4.getCoinType(coin);
+    }
+
+    /// @notice Internal fn called when the PoolManager is unlocked. Used to mint initial liquidity positions and burn positions during migration.
     function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {
         return V4Liquidity.handleCallback(poolManager, data);
     }
@@ -371,7 +426,14 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
         }
 
         newPoolKey = V4Liquidity.lockAndMigrate(poolManager, poolKey, poolCoin.positions, poolCoin.coin, newHook, additionalData);
+
+        // Delete the old pool key mapping to prevent future operations on the migrated pool
+        delete poolCoins[poolKeyHash];
     }
 
+    /// @notice Receives ETH from the pool manager for ETH-backed coins during fee collection.
+    /// @dev Only required for coins using ETH as backing currency (currency = address(0)).
+    ///      Restricted to onlyPoolManager to prevent ETH from getting stuck in the contract.
+    ///      Unused for ERC20-backed coins.
     receive() external payable onlyPoolManager {}
 }

package/src/interfaces/ICoin.sol

@@ -50,7 +50,25 @@ interface IHasSwapPath {
     function getPayoutSwapPath(IDeployedCoinVersionLookup coinVersionLookup) external view returns (PayoutSwapPath memory);
 }
 
-interface ICoin is IERC165, IERC7572, IDopplerErrors, IHasRewardsRecipients, IHasPoolKey, IHasSwapPath {
+interface IHasTotalSupplyForPositions {
+    /// @notice Returns the total supply of all positions for this coin
+    /// @return The total supply of all positions
+    function totalSupplyForPositions() external view returns (uint256);
+}
+
+interface IHasCoinType {
+    /// @notice The type of coin
+    enum CoinType {
+        Creator,
+        Content
+    }
+
+    /// @notice Returns the type of coin
+    /// @return The type of coin
+    function coinType() external view returns (CoinType);
+}
+
+interface ICoin is IERC165, IERC7572, IDopplerErrors, IHasRewardsRecipients, IHasPoolKey, IHasSwapPath, IHasTotalSupplyForPositions, IHasCoinType {
     /// @notice Thrown when the name is required for the coin
     error NameIsRequired();
 

package/src/interfaces/ICreatorCoin.sol

@@ -18,4 +18,8 @@ interface ICreatorCoin is ICoin {
     /// @notice Allows the creator payout recipient to claim vested tokens
     /// @return claimAmount The amount of tokens claimed
     function claimVesting() external returns (uint256);
+
+    /// @notice Get the amount of vested tokens that can be claimed
+    /// @return claimAmount The amount of tokens that can be claimed
+    function getClaimableAmount() external view returns (uint256);
 }

package/src/interfaces/IUpgradeableV4Hook.sol

@@ -50,3 +50,21 @@ interface IUpgradeableDestinationV4Hook {
         bytes calldata additionalData
     ) external;
 }
+
+interface IUpgradeableDestinationV4HookWithUpdateableFee {
+    /// @notice Initialize after migration from old hook
+    /// @param poolKey The pool key being migrated
+    /// @param coin The coin address
+    /// @param sqrtPriceX96 The current sqrt price
+    /// @param migratedLiquidity The migrated liquidity
+    /// @param additionalData Additional data for initialization
+    /// @return fee The new fee for the migrated liquidity
+    /// @return tickSpacing The new tick spacing for the migrated liquidity
+    function initializeFromMigrationWithUpdateableFee(
+        PoolKey calldata poolKey,
+        address coin,
+        uint160 sqrtPriceX96,
+        BurnedPosition[] calldata migratedLiquidity,
+        bytes calldata additionalData
+    ) external returns (uint24 fee, int24 tickSpacing);
+}

package/src/interfaces/IZoraFactory.sol

@@ -83,6 +83,21 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
     /// @notice Thrown when ETH is sent with a transaction but the currency is not WETH
     error EthTransferInvalid();
 
+    /// @notice Thrown when the hook is invalid
+    error InvalidHook();
+
+    /// @notice Occurs when attempting to upgrade to a contract with a name that doesn't match the current contract's name
+    /// @param currentName The name of the current contract
+    /// @param newName The name of the contract being upgraded to
+    error UpgradeToMismatchedContractName(string currentName, string newName);
+
+    /// @notice Thrown when a method is deprecated
+    error Deprecated();
+
+    /// @notice Thrwon when an invalid config version is provided
+    error InvalidConfig();
+
+    /// @dev Deprecated: use `deployCreatorCoin` instead that has a salt and post-deploy hook specified
     function deployCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
@@ -94,6 +109,33 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
         bytes32 coinSalt
     ) external returns (address);
 
+    /// @notice Creates a new creator coin contract with an optional hook that runs after the coin is deployed.
+    /// Enables buying initial supply by supporting ETH transfers to the post-deploy hook.
+    /// @param payoutRecipient The recipient of creator reward payouts; this can be updated by an owner
+    /// @param owners The list of addresses that will be able to manage the coin's payout address and metadata uri
+    /// @param uri The coin metadata uri
+    /// @param name The name of the coin
+    /// @param symbol The symbol of the coin
+    /// @param poolConfig The config parameters for the coin's pool
+    /// @param platformReferrer The address of the platform referrer
+    /// @param postDeployHook The address of the hook to run after the coin is deployed
+    /// @param postDeployHookData The data to pass to the hook
+    /// @param coinSalt The salt used to deploy the coin
+    /// @return coin The address of the deployed creator coin
+    /// @return postDeployHookDataOut The data returned by the hook
+    function deployCreatorCoin(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address postDeployHook,
+        bytes calldata postDeployHookData,
+        bytes32 coinSalt
+    ) external payable returns (address coin, bytes memory postDeployHookDataOut);
+
     /// @notice Creates a new coin contract with an optional hook that runs after the coin is deployed.
     /// Requires a salt to be specified, which enabled the coin to be deployed deterministically, and at
     /// a predictable address.
@@ -163,19 +205,18 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
         bytes calldata hookData
     ) external payable returns (address coin, bytes memory hookDataOut);
 
+    /// @notice The implementation address of the factory contract
     function implementation() external view returns (address);
 
-    /// @notice Thrown when the hook is invalid
-    error InvalidHook();
+    /// @notice The address of the latest coin hook
+    function hook() external view returns (address);
 
-    /// @notice Occurs when attempting to upgrade to a contract with a name that doesn't match the current contract's name
-    /// @param currentName The name of the current contract
-    /// @param newName The name of the contract being upgraded to
-    error UpgradeToMismatchedContractName(string currentName, string newName);
+    /// @notice The address of the latest content coin hook
+    function contentCoinHook() external view returns (address);
 
-    /// @notice Thrown when a method is deprecated
-    error Deprecated();
+    /// @notice The address of the latestcreator coin hook
+    function creatorCoinHook() external view returns (address);
 
-    /// @notice Thrwon when an invalid config version is provided
-    error InvalidConfig();
+    /// @notice The address of the Zora hook registry
+    function zoraHookRegistry() external view returns (address);
 }

package/src/interfaces/IZoraHookRegistry.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+interface IZoraHookRegistry {
+    /// @notice Zora hook data
+    struct ZoraHook {
+        address hook;
+        string tag;
+        string version;
+    }
+
+    /// @notice Emitted when a hook is added to the registry
+    event ZoraHookRegistered(address indexed hook, string tag, string version);
+
+    /// @notice Emitted when a hook is removed from the registry
+    event ZoraHookRemoved(address indexed hook, string tag, string version);
+
+    /// @dev Reverts when the length of the hooks and tags arrays do not match
+    error ArrayLengthMismatch();
+
+    /// @notice Returns whether a hook is currently registered
+    function isRegisteredHook(address hook) external view returns (bool);
+
+    /// @notice Returns all registered hooks
+    function getHooks() external view returns (ZoraHook[] memory);
+
+    /// @notice Returns all registered hook addresses
+    function getHookAddresses() external view returns (address[] memory);
+
+    /// @notice Returns the tag for a hook
+    function getHookTag(address hook) external view returns (string memory);
+
+    /// @notice Returns the contract version for a hook if it exists
+    function getHookVersion(address hook) external view returns (string memory);
+
+    /// @notice Adds hooks to the registry
+    function registerHooks(address[] calldata hooks, string[] calldata tags) external;
+
+    /// @notice Removes hooks from the registry
+    function removeHooks(address[] calldata hooks) external;
+}