@zoralabs/coins 2.1.2 → 2.3.0

package/src/BaseCoin.sol

@@ -9,7 +9,7 @@ pragma solidity ^0.8.23;
 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import {ICoin} from "./interfaces/ICoin.sol";
+import {ICoin, IHasTotalSupplyForPositions, IHasCoinType} from "./interfaces/ICoin.sol";
 import {IHasRewardsRecipients} from "./interfaces/IHasRewardsRecipients.sol";
 import {ICoinComments} from "./interfaces/ICoinComments.sol";
 import {IERC7572} from "./interfaces/IERC7572.sol";
@@ -32,7 +32,6 @@ import {CoinCommon} from "./libs/CoinCommon.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {ERC20PermitUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol";
 import {ERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
-import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {ContractVersionBase} from "./version/ContractVersionBase.sol";
 import {MultiOwnable} from "./utils/MultiOwnable.sol";
@@ -40,7 +39,6 @@ import {FullMath} from "./utils/uniswap/FullMath.sol";
 import {TickMath} from "./utils/uniswap/TickMath.sol";
 import {LiquidityAmounts} from "./utils/uniswap/LiquidityAmounts.sol";
 import {CoinConstants} from "./libs/CoinConstants.sol";
-import {MarketConstants} from "./libs/MarketConstants.sol";
 import {LpPosition} from "./types/LpPosition.sol";
 import {PoolState} from "./types/PoolState.sol";
 
@@ -54,7 +52,7 @@ import {PoolState} from "./types/PoolState.sol";
     \$$$$$$  | $$$$$$  |$$$$$$\ $$ | \$$ |
      \______/  \______/ \______|\__|  \__|
 */
-abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ReentrancyGuardUpgradeable, ERC165Upgradeable {
+abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ERC165Upgradeable {
     using SafeERC20 for IERC20;
 
     /// @notice The address of the protocol rewards contract
@@ -89,28 +87,29 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
 
     /**
      * @notice The constructor for the static Coin contract deployment shared across all Coins.
-     * @param _protocolRewardRecipient The address of the protocol reward recipient
-     * @param _protocolRewards The address of the protocol rewards contract
-     * @param _airlock The address of the Airlock contract
+     * @param protocolRewardRecipient_ The address of the protocol reward recipient
+     * @param protocolRewards_ The address of the protocol rewards contract
+     * @param poolManager_ The address of the pool manager
+     * @param airlock_ The address of the Airlock contract
      */
-    constructor(address _protocolRewardRecipient, address _protocolRewards, IPoolManager poolManager_, address _airlock) initializer {
-        if (_protocolRewardRecipient == address(0)) {
+    constructor(address protocolRewardRecipient_, address protocolRewards_, IPoolManager poolManager_, address airlock_) initializer {
+        if (protocolRewardRecipient_ == address(0)) {
             revert AddressZero();
         }
-        if (_protocolRewards == address(0)) {
+        if (protocolRewards_ == address(0)) {
             revert AddressZero();
         }
         if (address(poolManager_) == address(0)) {
             revert AddressZero();
         }
-        if (_airlock == address(0)) {
+        if (airlock_ == address(0)) {
             revert AddressZero();
         }
 
-        protocolRewardRecipient = _protocolRewardRecipient;
-        protocolRewards = _protocolRewards;
+        protocolRewardRecipient = protocolRewardRecipient_;
+        protocolRewards = protocolRewards_;
         poolManager = poolManager_;
-        airlock = _airlock;
+        airlock = airlock_;
     }
 
     /// @inheritdoc ICoin
@@ -167,7 +166,6 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         __ERC20Permit_init("");
 
         __MultiOwnable_init(owners_);
-        __ReentrancyGuard_init();
 
         // Set mutable state
         _setPayoutRecipient(payoutRecipient_);
@@ -180,14 +178,9 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
         _handleInitialDistribution();
     }
 
-    /// @dev The initial mint and distribution of the coin supply.
-    function _handleInitialDistribution() internal virtual {
-        // Mint the total supply to the coin contract
-        _mint(address(this), CoinConstants.MAX_TOTAL_SUPPLY);
-
-        // Distribute the creator launch reward to the payout recipient
-        _transfer(address(this), payoutRecipient, CoinConstants.CREATOR_LAUNCH_REWARD);
-    }
+    /// @notice The initial mint and distribution of the coin supply.
+    /// @dev This function must be overridden by the child contract.
+    function _handleInitialDistribution() internal virtual;
 
     /// @notice Returns the name of the token for EIP712 domain.
     /// @notice This can change when the user changes the "name" of the token.
@@ -258,7 +251,9 @@ abstract contract BaseCoin is ICoin, ContractVersionBase, ERC20PermitUpgradeable
             interfaceId == type(IERC7572).interfaceId ||
             interfaceId == type(IHasRewardsRecipients).interfaceId ||
             interfaceId == type(IHasPoolKey).interfaceId ||
-            type(IHasSwapPath).interfaceId == interfaceId;
+            interfaceId == type(IHasCoinType).interfaceId ||
+            interfaceId == type(IHasTotalSupplyForPositions).interfaceId ||
+            interfaceId == type(IHasSwapPath).interfaceId;
     }
 
     /// @dev Overrides ERC20's _update function to emit a superset `CoinTransfer` event

package/src/ContentCoin.sol

@@ -10,10 +10,11 @@ pragma solidity ^0.8.23;
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {BaseCoin} from "./BaseCoin.sol";
 import {CoinConstants} from "./libs/CoinConstants.sol";
+import {IHasCoinType} from "./interfaces/ICoin.sol";
 
 /**
  * @title ContentCoin
- * @notice Content coin implementation that uses creator coins as backing currency
+ * @notice Content coin implementation that typically uses creator coins as backing currency, but can be set to any currency as the backing currency
  * @dev Inherits from BaseCoin and implements content-specific distribution logic
  */
 contract ContentCoin is BaseCoin {
@@ -37,9 +38,17 @@ contract ContentCoin is BaseCoin {
         _mint(address(this), CoinConstants.MAX_TOTAL_SUPPLY);
 
         // Distribute the creator launch reward to the payout recipient
-        _transfer(address(this), payoutRecipient, CoinConstants.CREATOR_LAUNCH_REWARD);
+        _transfer(address(this), payoutRecipient, CoinConstants.CONTENT_COIN_INITIAL_CREATOR_SUPPLY);
 
         // Transfer the market supply to the hook for liquidity
         _transfer(address(this), address(poolKey.hooks), balanceOf(address(this)));
     }
+
+    function totalSupplyForPositions() external pure override returns (uint256) {
+        return CoinConstants.CONTENT_COIN_MARKET_SUPPLY;
+    }
+
+    function coinType() external pure override returns (IHasCoinType.CoinType) {
+        return IHasCoinType.CoinType.Content;
+    }
 }

package/src/CreatorCoin.sol

@@ -8,10 +8,11 @@
 pragma solidity ^0.8.28;
 
 import {ICreatorCoin} from "./interfaces/ICreatorCoin.sol";
-import {CreatorCoinConstants} from "./libs/CreatorCoinConstants.sol";
+import {CoinConstants} from "./libs/CoinConstants.sol";
 import {IHooks, PoolConfiguration, PoolKey, ICoin} from "./interfaces/ICoin.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {BaseCoin} from "./BaseCoin.sol";
+import {IHasCoinType} from "./interfaces/ICoin.sol";
 
 contract CreatorCoin is ICreatorCoin, BaseCoin {
     uint256 public vestingStartTime;
@@ -19,11 +20,19 @@ contract CreatorCoin is ICreatorCoin, BaseCoin {
     uint256 public totalClaimed;
 
     constructor(
-        address _protocolRewardRecipient,
-        address _protocolRewards,
-        IPoolManager _poolManager,
-        address _airlock
-    ) BaseCoin(_protocolRewardRecipient, _protocolRewards, _poolManager, _airlock) initializer {}
+        address protocolRewardRecipient_,
+        address protocolRewards_,
+        IPoolManager poolManager_,
+        address airlock_
+    ) BaseCoin(protocolRewardRecipient_, protocolRewards_, poolManager_, airlock_) initializer {}
+
+    function totalSupplyForPositions() external pure override returns (uint256) {
+        return CoinConstants.CREATOR_COIN_MARKET_SUPPLY;
+    }
+
+    function coinType() external pure override returns (IHasCoinType.CoinType) {
+        return IHasCoinType.CoinType.Creator;
+    }
 
     function initialize(
         address payoutRecipient_,
@@ -37,24 +46,34 @@ contract CreatorCoin is ICreatorCoin, BaseCoin {
         uint160 sqrtPriceX96,
         PoolConfiguration memory poolConfiguration_
     ) public override(BaseCoin, ICoin) {
-        require(currency_ == CreatorCoinConstants.CURRENCY, InvalidCurrency());
-
-        super.initialize(payoutRecipient_, owners_, tokenURI_, name_, symbol_, platformReferrer_, currency_, poolKey_, sqrtPriceX96, poolConfiguration_);
+        require(currency_ == CoinConstants.CREATOR_COIN_CURRENCY, InvalidCurrency());
+
+        super.initialize({
+            payoutRecipient_: payoutRecipient_,
+            owners_: owners_,
+            tokenURI_: tokenURI_,
+            name_: name_,
+            symbol_: symbol_,
+            platformReferrer_: platformReferrer_,
+            currency_: currency_,
+            poolKey_: poolKey_,
+            sqrtPriceX96: sqrtPriceX96,
+            poolConfiguration_: poolConfiguration_
+        });
 
         vestingStartTime = block.timestamp;
-        vestingEndTime = block.timestamp + CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        vestingEndTime = block.timestamp + CoinConstants.CREATOR_VESTING_DURATION;
     }
 
     /// @dev The initial mint and distribution of the coin supply.
     ///      Implements creator coin specific distribution: 500M to liquidity pool, 500M vested to creator.
     function _handleInitialDistribution() internal override {
-        _mint(address(this), CreatorCoinConstants.TOTAL_SUPPLY);
+        _mint(address(this), CoinConstants.TOTAL_SUPPLY);
 
-        _transfer(address(this), address(poolKey.hooks), CreatorCoinConstants.MARKET_SUPPLY);
+        _transfer(address(this), address(poolKey.hooks), CoinConstants.CREATOR_COIN_MARKET_SUPPLY);
     }
 
     /// @notice Allows the creator payout recipient to claim vested tokens
-    /// @dev Optimized for frequent calls from Uniswap V4 hooks
     /// @return claimAmount The amount of tokens claimed
     function claimVesting() external returns (uint256) {
         uint256 claimAmount = getClaimableAmount();
@@ -93,13 +112,13 @@ contract CreatorCoin is ICreatorCoin, BaseCoin {
 
         // After vesting ends - fully vested
         if (timestamp >= vestingEndTime) {
-            return CreatorCoinConstants.CREATOR_VESTING_SUPPLY;
+            return CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY;
         }
 
         // Linear vesting: (elapsed_time / total_duration) * total_amount
         uint256 elapsedTime = timestamp - vestingStartTime;
 
         // Multiply first to avoid precision loss
-        return (CreatorCoinConstants.CREATOR_VESTING_SUPPLY * elapsedTime) / CreatorCoinConstants.CREATOR_VESTING_DURATION;
+        return (CoinConstants.CREATOR_COIN_CREATOR_VESTING_SUPPLY * elapsedTime) / CoinConstants.CREATOR_VESTING_DURATION;
     }
 }

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";
@@ -33,8 +34,8 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 import {CoinSetup} from "./libs/CoinSetup.sol";
 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 +48,25 @@ 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_;
     }
 
+    /// @inheritdoc IZoraFactory
     function deployCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
@@ -73,39 +78,24 @@ contract ZoraFactoryImpl is
         bytes32 coinSalt
     ) public nonReentrant returns (address) {
         bytes32 salt = _buildSalt(msg.sender, name, symbol, poolConfig, platformReferrer, coinSalt);
+        return address(_createAndInitializeCreatorCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
+    }
 
-        uint8 version = CoinConfigurationVersions.getVersion(poolConfig);
-
-        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, InvalidConfig());
-
-        address creatorCoin = Clones.cloneDeterministic(creatorCoinImpl, salt);
-
-        _setVersionForDeployedCoin(address(creatorCoin), version);
-
-        (, address currency, uint160 sqrtPriceX96, bool isCoinToken0, PoolConfiguration memory poolConfiguration) = CoinSetup.generatePoolConfig(
-            address(creatorCoin),
-            poolConfig
-        );
-
-        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(creatorCoin), currency, isCoinToken0, IHooks(creatorCoinHook));
-
-        ICreatorCoin(creatorCoin).initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
-
-        emit CreatorCoinCreated(
-            msg.sender,
-            payoutRecipient,
-            platformReferrer,
-            currency,
-            uri,
-            name,
-            symbol,
-            address(creatorCoin),
-            poolKey,
-            CoinCommon.hashPoolKey(poolKey),
-            IVersionedContract(address(creatorCoin)).contractVersion()
-        );
-
-        return creatorCoin;
+    /// @inheritdoc IZoraFactory
+    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 nonReentrant returns (address coin, bytes memory postDeployHookDataOut) {
+        bytes32 salt = _buildSalt(msg.sender, name, symbol, poolConfig, platformReferrer, coinSalt);
+        return _deployCreatorCoinWithHook(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, postDeployHook, postDeployHookData, salt);
     }
 
     /// @inheritdoc IZoraFactory
@@ -125,6 +115,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 +128,19 @@ contract ZoraFactoryImpl is
         return Clones.predictDeterministicAddress(getCoinImpl(CoinConfigurationVersions.getVersion(poolConfig)), salt, address(this));
     }
 
+    function _executePostDeployHook(address coin, address deployHook, bytes calldata hookData) internal returns (bytes memory hookDataOut) {
+        if (deployHook != address(0)) {
+            if (!IERC165(deployHook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
+                revert InvalidHook();
+            }
+            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();
+        }
+    }
+
+    /// @dev Internal function to deploy a coin with a hook
     function _deployWithHook(
         address payoutRecipient,
         address[] memory owners,
@@ -145,24 +149,34 @@ 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));
+        hookDataOut = _executePostDeployHook(coin, deployHook, hookData);
+    }
 
-        if (hook != address(0)) {
-            if (!IERC165(hook).supportsInterface(type(IHasAfterCoinDeploy).interfaceId)) {
-                revert InvalidHook();
-            }
-            hookDataOut = IHasAfterCoinDeploy(hook).afterCoinDeploy{value: msg.value}(msg.sender, ICoin(coin), hookData);
-        } else if (msg.value > 0) {
-            // cannot send eth without a hook
-            revert EthTransferInvalid();
-        }
+    /// @dev Internal function to deploy a creator coin with a hook
+    function _deployCreatorCoinWithHook(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address deployHook,
+        bytes calldata hookData,
+        bytes32 salt
+    ) internal returns (address coin, bytes memory hookDataOut) {
+        coin = address(_createAndInitializeCreatorCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer, salt));
+        hookDataOut = _executePostDeployHook(coin, deployHook, hookData);
     }
 
-    /** Deprecated deploy functions */
+    /**
+     * Deprecated deploy functions
+     */
 
     /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
     function deploy(
@@ -193,11 +207,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 +224,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 +236,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;
@@ -229,29 +248,55 @@ contract ZoraFactoryImpl is
         revert ICoin.InvalidPoolVersion();
     }
 
-    function _createCoin(uint8 version, bytes32 salt) internal returns (address payable) {
-        return payable(Clones.cloneDeterministic(getCoinImpl(version), salt));
+    function _createCoinWithPoolConfig(
+        address _implementation,
+        bytes memory poolConfig,
+        bytes32 coinSalt,
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        address platformReferrer
+    ) internal returns (address coin, uint8 version, PoolKey memory poolKey, address currency) {
+        version = CoinConfigurationVersions.getVersion(poolConfig);
+        coin = Clones.cloneDeterministic(_implementation, coinSalt);
+        _setVersionForDeployedCoin(coin, version);
+
+        uint160 sqrtPriceX96;
+        bool isCoinToken0;
+        PoolConfiguration memory poolConfiguration;
+        (, currency, sqrtPriceX96, isCoinToken0, poolConfiguration) = CoinSetup.generatePoolConfig(coin, poolConfig);
+
+        poolKey = CoinSetup.buildPoolKey(coin, currency, isCoinToken0, IHooks(hook));
+        ICoin(coin).initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
     }
 
-    function _setupV4Coin(
-        ICoin coin,
-        address currency,
-        bool isCoinToken0,
-        uint160 sqrtPriceX96,
-        PoolConfiguration memory poolConfiguration,
+    function _createAndInitializeCreatorCoin(
         address payoutRecipient,
         address[] memory owners,
         string memory uri,
         string memory name,
         string memory symbol,
-        address platformReferrer
-    ) internal {
-        PoolKey memory poolKey = CoinSetup.buildPoolKey(address(coin), currency, isCoinToken0, IHooks(contentCoinHook));
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) internal returns (ICreatorCoin) {
+        (address creatorCoin, uint8 version, PoolKey memory poolKey, address currency) = _createCoinWithPoolConfig(
+            creatorCoinImpl,
+            poolConfig,
+            coinSalt,
+            payoutRecipient,
+            owners,
+            uri,
+            name,
+            symbol,
+            platformReferrer
+        );
 
-        // Initialize coin with pre-configured pool
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, platformReferrer, currency, poolKey, sqrtPriceX96, poolConfiguration);
+        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, InvalidConfig());
 
-        emit CoinCreatedV4(
+        emit CreatorCoinCreated(
             msg.sender,
             payoutRecipient,
             platformReferrer,
@@ -259,11 +304,13 @@ contract ZoraFactoryImpl is
             uri,
             name,
             symbol,
-            address(coin),
+            creatorCoin,
             poolKey,
             CoinCommon.hashPoolKey(poolKey),
-            IVersionedContract(address(coin)).contractVersion()
+            IVersionedContract(creatorCoin).contractVersion()
         );
+
+        return ICreatorCoin(creatorCoin);
     }
 
     function _createAndInitializeCoin(
@@ -276,26 +323,34 @@ contract ZoraFactoryImpl is
         address platformReferrer,
         bytes32 coinSalt
     ) internal returns (ICoin) {
-        uint8 version = CoinConfigurationVersions.getVersion(poolConfig);
-
-        address payable coin = _createCoin(version, coinSalt);
+        (address coin, uint8 version, PoolKey memory poolKey, address currency) = _createCoinWithPoolConfig(
+            coinV4Impl,
+            poolConfig,
+            coinSalt,
+            payoutRecipient,
+            owners,
+            uri,
+            name,
+            symbol,
+            platformReferrer
+        );
 
-        _setVersionForDeployedCoin(address(coin), version);
+        require(version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, ICoin.InvalidPoolVersion());
 
-        (, address currency, uint160 sqrtPriceX96, bool isCoinToken0, PoolConfiguration memory poolConfiguration) = CoinSetup.generatePoolConfig(
-            address(coin),
-            poolConfig
+        emit CoinCreatedV4(
+            msg.sender,
+            payoutRecipient,
+            platformReferrer,
+            currency,
+            uri,
+            name,
+            symbol,
+            coin,
+            poolKey,
+            CoinCommon.hashPoolKey(poolKey),
+            IVersionedContract(coin).contractVersion()
         );
 
-        if (CoinConfigurationVersions.isV3(version)) {
-            // V3 is no longer supported
-            revert ICoin.InvalidPoolVersion();
-        } else if (CoinConfigurationVersions.isV4(version)) {
-            _setupV4Coin(ICoin(coin), currency, isCoinToken0, sqrtPriceX96, poolConfiguration, payoutRecipient, owners, uri, name, symbol, platformReferrer);
-        } else {
-            revert ICoin.InvalidPoolVersion();
-        }
-
         return ICoin(coin);
     }
 
@@ -310,7 +365,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 +408,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;
     }
 }