@zoralabs/coins 2.1.1 → 2.2.1

package/src/ZoraFactoryImpl.sol

@@ -8,6 +8,7 @@
 pragma solidity ^0.8.23;
 
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 import {Ownable2StepUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
 import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
@@ -35,6 +36,7 @@ import {CoinDopplerMultiCurve} from "./libs/CoinDopplerMultiCurve.sol";
 import {ICreatorCoin} from "./interfaces/ICreatorCoin.sol";
 import {MarketConstants} from "./libs/MarketConstants.sol";
 import {DeployedCoinVersionLookup} from "./utils/DeployedCoinVersionLookup.sol";
+import {IZoraHookRegistry} from "./interfaces/IZoraHookRegistry.sol";
 
 contract ZoraFactoryImpl is
     IZoraFactory,
@@ -47,21 +49,33 @@ contract ZoraFactoryImpl is
 {
     using SafeERC20 for IERC20;
 
-    /// @notice The coin contract implementation address
+    /// @notice The ZORA coin contract implementation address
     address public immutable coinV4Impl;
+    /// @notice The creator coin contract implementation address
     address public immutable creatorCoinImpl;
-    address public immutable contentCoinHook;
-    address public immutable creatorCoinHook;
+    /// @notice The uniswap v4 coin hook address
+    address public immutable hook;
+    /// @notice The zora hook registry address
+    address public immutable zoraHookRegistry;
 
-    constructor(address _coinV4Impl, address _creatorCoinImpl, address _contentCoinHook, address _creatorCoinHook) {
+    constructor(address coinV4Impl_, address creatorCoinImpl_, address hook_, address zoraHookRegistry_) {
         _disableInitializers();
 
-        coinV4Impl = _coinV4Impl;
-        creatorCoinImpl = _creatorCoinImpl;
-        contentCoinHook = _contentCoinHook;
-        creatorCoinHook = _creatorCoinHook;
+        coinV4Impl = coinV4Impl_;
+        creatorCoinImpl = creatorCoinImpl_;
+        hook = hook_;
+        zoraHookRegistry = zoraHookRegistry_;
     }
 
+    /// @notice Creates a new creator coin contract
+    /// @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 coinSalt The salt used to deploy the coin
     function deployCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
@@ -87,7 +101,7 @@ contract ZoraFactoryImpl is
             poolConfig
         );
 
-        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(creatorCoin), currency, isCoinToken0, IHooks(creatorCoinHook));
+        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(creatorCoin), currency, isCoinToken0, IHooks(hook));
 
         ICreatorCoin(creatorCoin).initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
 
@@ -125,6 +139,7 @@ contract ZoraFactoryImpl is
         return _deployWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, postDeployHook, postDeployHookData, salt);
     }
 
+    /// @inheritdoc IZoraFactory
     function coinAddress(
         address msgSender,
         string memory name,
@@ -137,6 +152,7 @@ contract ZoraFactoryImpl is
         return Clones.predictDeterministicAddress(getCoinImpl(CoinConfigurationVersions.getVersion(poolConfig)), salt, address(this));
     }
 
+    /// @dev Internal function to deploy a coin with a hook
     function _deployWithHook(
         address payoutRecipient,
         address[] memory owners,
@@ -145,24 +161,26 @@ contract ZoraFactoryImpl is
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
-        address hook,
+        address deployHook,
         bytes calldata hookData,
         bytes32 salt
     ) internal returns (address coin, bytes memory hookDataOut) {
         coin = address(_createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
 
-        if (hook != address(0)) {
-            if (!IERC165(hook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
+        if (deployHook != address(0)) {
+            if (!IERC165(deployHook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
                 revert InvalidHook();
             }
-            hookDataOut = IHasAfterCoinDeploy(hook).afterCoinDeploy{value: msg.value}(msg.sender, ICoin(coin), hookData);
+            hookDataOut = IHasAfterCoinDeploy(deployHook).afterCoinDeploy{value: msg.value}(msg.sender, ICoin(coin), hookData);
         } else if (msg.value > 0) {
             // cannot send eth without a hook
             revert EthTransferInvalid();
         }
     }
 
-    /** Deprecated deploy functions */
+    /**
+     * Deprecated deploy functions
+     */
 
     /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
     function deploy(
@@ -193,11 +211,11 @@ contract ZoraFactoryImpl is
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
-        address hook,
+        address deployHook,
         bytes calldata hookData
     ) public payable nonReentrant returns (address coin, bytes memory hookDataOut) {
         bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
-        return _deployWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, hook, hookData, salt);
+        return _deployWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, deployHook, hookData, salt);
     }
 
     /// @dev deprecated Use deploy() with poolConfig instead
@@ -210,8 +228,9 @@ contract ZoraFactoryImpl is
         address platformReferrer,
         address currency,
         // tickLower is no longer used
-        int24 /*tickLower*/,
-        uint256 orderSize
+        int24 /* tickLower */,
+        // orderSize is no longer used
+        uint256 /* orderSize */
     ) public payable nonReentrant returns (address, uint256) {
         bytes memory poolConfig = CoinConfigurationVersions.defaultConfig(currency);
         bytes32 salt = _randomSalt(payoutRecipient, uri, bytes32(0));
@@ -221,6 +240,10 @@ contract ZoraFactoryImpl is
         return (address(coin), 0);
     }
 
+    /**
+     * End Deprecated deploy functions
+     */
+
     function getCoinImpl(uint8 version) internal view returns (address) {
         if (CoinConfigurationVersions.isV4(version)) {
             return coinV4Impl;
@@ -246,7 +269,7 @@ contract ZoraFactoryImpl is
         string memory symbol,
         address platformReferrer
     ) internal {
-        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(coin), currency, isCoinToken0, IHooks(contentCoinHook));
+        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(coin), currency, isCoinToken0, IHooks(hook));
 
         // Initialize coin with pre-configured pool
         coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
@@ -310,7 +333,6 @@ contract ZoraFactoryImpl is
         return keccak256(abi.encodePacked(msgSender, name, symbol, poolConfig, platformReferrer, coinSalt));
     }
 
-    /// @dev Generates a unique salt for deterministic deployment
     function _randomSalt(address payoutRecipient, string memory uri, bytes32 coinSalt) internal view returns (bytes32) {
         return
             keccak256(
@@ -354,13 +376,30 @@ contract ZoraFactoryImpl is
         // try to get the existing contract name - if it reverts, the existing contract was an older version that didn't have the contract name
         // unfortunately we cannot use supportsInterface here because the existing implementation did not have that function
         try IHasContractName(newImpl).contractName() returns (string memory name) {
-            if (!_equals(name, contractName())) {
+            if (!Strings.equal(name, contractName())) {
                 revert UpgradeToMismatchedContractName(contractName(), name);
             }
         } catch {}
+
+        // Auto-register the new hooks in the Zora hook registry
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = IZoraFactory(newImpl).hook();
+        tags[0] = "CoinHook";
+
+        IZoraHookRegistry(zoraHookRegistry).registerHooks(hooks, tags);
+    }
+
+    /// @notice The address of the latest creator coin hook
+    /// @dev Deprecated: use `hook` instead
+    function creatorCoinHook() external view returns (address) {
+        return hook;
     }
 
-    function _equals(string memory a, string memory b) internal pure returns (bool) {
-        return (keccak256(bytes(a)) == keccak256(bytes(b)));
+    /// @notice The address of the latest coin hook
+    /// @dev Deprecated: use `hook` instead
+    function contentCoinHook() external view returns (address) {
+        return hook;
     }
 }

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,93 @@
+// 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;
+
+    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}

@@ -37,6 +37,7 @@ 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";
 
 /// @title ZoraV4CoinHook
 /// @notice Uniswap V4 hook that automatically handles fee collection and reward distributions on every swap,
@@ -48,7 +49,7 @@ 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 {
     using BalanceDeltaLibrary for BalanceDelta;
 
     /// @notice Mapping of trusted message senders - these are addresses that are trusted to provide a
@@ -64,8 +65,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 +74,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 +82,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;
@@ -143,7 +140,7 @@ abstract contract BaseZoraV4CoinHook is BaseHook, ContractVersionBase, IZoraV4Co
     function _generatePositions(ICoin coin, PoolKey memory key) internal view returns (LpPosition[] memory positions) {
         bool isCoinToken0 = Currency.unwrap(key.currency0) == address(coin);
 
-        positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, coin.getPoolConfiguration(), totalSupplyForPositions);
+        positions = CoinDopplerMultiCurve.calculatePositions(isCoinToken0, coin.getPoolConfiguration(), coin.totalSupplyForPositions());
     }
 
     /// @notice Internal fn called when a pool is initialized.
@@ -336,7 +333,15 @@ 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);
+    }
+
+    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.
     function unlockCallback(bytes calldata data) external onlyPoolManager returns (bytes memory) {

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/IZoraFactory.sol

@@ -83,6 +83,29 @@ 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();
+
+    /// @notice Creates a new creator coin contract
+    /// @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 coinSalt The salt used to deploy the coin
     function deployCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
@@ -163,19 +186,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);
 }