@zoralabs/coins 0.7.0 → 0.9.0

package/src/Coin.sol

@@ -18,15 +18,16 @@ import {ERC20PermitUpgradeable} from "@openzeppelin/contracts-upgradeable/token/
 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 {CoinConstants} from "./utils/CoinConstants.sol";
 import {MultiOwnable} from "./utils/MultiOwnable.sol";
 import {FullMath} from "./utils/uniswap/FullMath.sol";
 import {TickMath} from "./utils/uniswap/TickMath.sol";
 import {LiquidityAmounts} from "./utils/uniswap/LiquidityAmounts.sol";
-import {CoinSetup} from "./libs/CoinSetup.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";
+import {CoinSetupV3, UniV3Config, CoinV3Config} from "./libs/CoinSetupV3.sol";
+import {UniV3BuySell, CoinConfig} from "./libs/UniV3BuySell.sol";
 
 /*
      $$$$$$\   $$$$$$\  $$$$$$\ $$\   $$\ 
@@ -38,7 +39,7 @@ import {PoolState} from "./types/PoolState.sol";
     \$$$$$$  | $$$$$$  |$$$$$$\ $$ | \$$ |
      \______/  \______/ \______|\__|  \__|
 */
-contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ReentrancyGuardUpgradeable {
+contract Coin is ICoin, ContractVersionBase, ERC20PermitUpgradeable, MultiOwnable, ReentrancyGuardUpgradeable {
     using SafeERC20 for IERC20;
 
     /// @notice The address of the WETH contract
@@ -65,6 +66,11 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
     /// @notice The address of the currency
     address public currency;
 
+    /// @notice The state of the market
+    bytes public market;
+    uint8 public marketVersion;
+
+    /// @notice deprecated
     PoolConfiguration public poolConfiguration;
 
     /// @notice Returns the state of the pool
@@ -101,7 +107,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         isInitialized = true;
         isExited = false;
         maxShareToBeSold = poolConfiguration.maxDiscoverySupplyShare;
-        totalTokensOnBondingCurve = POOL_LAUNCH_SUPPLY;
+        totalTokensOnBondingCurve = CoinConstants.POOL_LAUNCH_SUPPLY;
     }
 
     /**
@@ -183,13 +189,31 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         platformReferrer = platformReferrer_ == address(0) ? protocolRewardRecipient : platformReferrer_;
 
         // Mint the total supply
-        _mint(address(this), MAX_TOTAL_SUPPLY);
+        _mint(address(this), CoinConstants.MAX_TOTAL_SUPPLY);
 
         // Distribute the creator launch reward
-        _transfer(address(this), payoutRecipient, CREATOR_LAUNCH_REWARD);
+        _transfer(address(this), payoutRecipient, CoinConstants.CREATOR_LAUNCH_REWARD);
+
+        UniV3Config memory uniswapV3Config = UniV3Config({weth: WETH, v3Factory: v3Factory, swapRouter: swapRouter, airlock: airlock});
 
         // Deploy the pool
-        _deployLiquidity(poolConfig_);
+        (currency, poolAddress, poolConfiguration) = CoinSetupV3.setupPool(poolConfig_, uniswapV3Config, address(this));
+
+        // Split out the deployment of liquidity to avoid stack too deep
+        CoinSetupV3.deployLiquidity(address(this), currency, poolConfiguration, poolAddress);
+    }
+
+    function buildCoinConfig() internal view returns (CoinConfig memory coinConfig) {
+        coinConfig = CoinConfig({
+            protocolRewardRecipient: protocolRewardRecipient,
+            platformReferrer: platformReferrer,
+            currency: currency,
+            payoutRecipient: payoutRecipient,
+            protocolRewards: protocolRewards,
+            poolConfiguration: poolConfiguration,
+            poolAddress: poolAddress,
+            uniswapV3Config: UniV3Config({weth: WETH, v3Factory: v3Factory, swapRouter: swapRouter, airlock: airlock})
+        });
     }
 
     /// @notice Executes a buy order
@@ -204,41 +228,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
     ) public payable nonReentrant returns (uint256, uint256) {
-        // Ensure the recipient is not the zero address
-        if (recipient == address(0)) {
-            revert AddressZero();
-        }
-
-        // Calculate the trade reward
-        uint256 tradeReward = _calculateReward(orderSize, TOTAL_FEE_BPS);
-
-        // Calculate the remaining size
-        uint256 trueOrderSize = orderSize - tradeReward;
-
-        // Handle incoming currency
-        _handleIncomingCurrency(orderSize, trueOrderSize);
-
-        // Set up the swap parameters
-        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: currency,
-            tokenOut: address(this),
-            fee: MarketConstants.LP_FEE,
-            recipient: recipient,
-            amountIn: trueOrderSize,
-            amountOutMinimum: minAmountOut,
-            sqrtPriceLimitX96: sqrtPriceLimitX96
-        });
-
-        // Execute the swap
-        uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
-
-        _handleTradeRewards(tradeReward, tradeReferrer);
-
-        _handleMarketRewards();
-
-        emit CoinBuy(msg.sender, recipient, tradeReferrer, amountOut, currency, tradeReward, trueOrderSize);
-
-        return (orderSize, amountOut);
+        return UniV3BuySell.buy(recipient, orderSize, minAmountOut, sqrtPriceLimitX96, tradeReferrer, address(this), buildCoinConfig());
     }
 
     /// @notice Executes a sell order
@@ -254,11 +244,6 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         uint160 sqrtPriceLimitX96,
         address tradeReferrer
     ) public nonReentrant returns (uint256, uint256) {
-        // Ensure the recipient is not the zero address
-        if (recipient == address(0)) {
-            revert AddressZero();
-        }
-
         // Record the coin balance of this contract before the swap
         uint256 beforeCoinBalance = balanceOf(address(this));
 
@@ -268,55 +253,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
         // Approve the Uniswap V3 swap router
         this.approve(swapRouter, orderSize);
 
-        // Set the swap parameters
-        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
-            tokenIn: address(this),
-            tokenOut: currency,
-            fee: MarketConstants.LP_FEE,
-            recipient: address(this),
-            amountIn: orderSize,
-            amountOutMinimum: minAmountOut,
-            sqrtPriceLimitX96: sqrtPriceLimitX96
-        });
-
-        // Execute the swap
-        uint256 amountOut = ISwapRouter(swapRouter).exactInputSingle(params);
-
-        // Record the coin balance of this contract after the swap
-        uint256 afterCoinBalance = balanceOf(address(this));
-
-        // If the swap was partially executed:
-        if (afterCoinBalance > beforeCoinBalance) {
-            // Calculate the refund
-            uint256 coinRefund = afterCoinBalance - beforeCoinBalance;
-
-            // Update the order size
-            orderSize -= coinRefund;
-
-            // Transfer the refund back to the seller
-            _transfer(address(this), recipient, coinRefund);
-        }
-
-        // If currency is WETH, convert to ETH
-        if (currency == WETH) {
-            IWETH(WETH).withdraw(amountOut);
-        }
-
-        // Calculate the trade reward
-        uint256 tradeReward = _calculateReward(amountOut, TOTAL_FEE_BPS);
-
-        // Calculate the payout after the fee
-        uint256 payoutSize = amountOut - tradeReward;
-
-        _handlePayout(payoutSize, recipient);
-
-        _handleTradeRewards(tradeReward, tradeReferrer);
-
-        _handleMarketRewards();
-
-        emit CoinSell(msg.sender, recipient, tradeReferrer, orderSize, currency, tradeReward, payoutSize);
-
-        return (orderSize, payoutSize);
+        return UniV3BuySell.sell(recipient, beforeCoinBalance, orderSize, minAmountOut, sqrtPriceLimitX96, tradeReferrer, buildCoinConfig());
     }
 
     /// @notice Enables a user to burn their tokens
@@ -330,7 +267,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
     /// @dev This function is a fallback, secondary rewards will be claimed automatically on each buy and sell.
     /// @param pushEthRewards Whether to push the ETH directly to the recipients.
     function claimSecondaryRewards(bool pushEthRewards) external nonReentrant {
-        MarketRewards memory rewards = _handleMarketRewards();
+        MarketRewards memory rewards = UniV3BuySell.handleMarketRewards(address(this), buildCoinConfig());
 
         if (pushEthRewards && rewards.totalAmountCurrency > 0 && currency == WETH) {
             IProtocolRewards(protocolRewards).withdrawFor(payoutRecipient, rewards.creatorPayoutAmountCurrency);
@@ -373,7 +310,7 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
 
     /// @dev Called by the pool after minting liquidity to transfer the associated coins
     function uniswapV3MintCallback(uint256 amount0Owed, uint256 amount1Owed, bytes calldata) external {
-        if (msg.sender != poolAddress) revert OnlyPool();
+        if (msg.sender != poolAddress) revert OnlyPool(msg.sender, poolAddress);
 
         IERC20(address(this)).safeTransfer(poolAddress, amount0Owed == 0 ? amount1Owed : amount0Owed);
     }
@@ -405,248 +342,4 @@ contract Coin is ICoin, CoinConstants, ContractVersionBase, ERC20PermitUpgradeab
 
         tokenURI = newURI;
     }
-
-    /// @dev Deploys the Uniswap V3 pool and mints initial liquidity based on the pool configuration
-    function _deployLiquidity(bytes memory poolConfig_) internal {
-        (uint8 version, address currency_) = abi.decode(poolConfig_, (uint8, address));
-
-        // Store the currency, defaulting to WETH if address(0)
-        currency = currency_ == address(0) ? WETH : currency_;
-
-        // Sort the token addresses
-        address token0 = address(this) < currency ? address(this) : currency;
-        address token1 = address(this) < currency ? currency : address(this);
-        bool isCoinToken0 = token0 == address(this);
-
-        (uint160 sqrtPriceX96, PoolConfiguration memory _poolConfig) = CoinSetup.setupPoolWithVersion(version, poolConfig_, isCoinToken0, WETH);
-
-        poolConfiguration = _poolConfig;
-
-        poolAddress = _createPool(token0, token1, sqrtPriceX96);
-
-        LpPosition[] memory positions = CoinSetup.calculatePositions(isCoinToken0, poolConfiguration);
-
-        _mintPositions(positions);
-    }
-
-    /// @dev Creates the Uniswap V3 pool for the coin/currency pair
-    function _createPool(address token0, address token1, uint160 sqrtPriceX96) internal returns (address pool) {
-        pool = IUniswapV3Factory(v3Factory).createPool(token0, token1, MarketConstants.LP_FEE);
-
-        // This pool should be new, if it has already been initialized
-        // then we will fail the creation step prompting the user to try again.
-        IUniswapV3Pool(pool).initialize(sqrtPriceX96);
-    }
-
-    /// @dev Mints the calculated liquidity positions into the Uniswap V3 pool
-    function _mintPositions(LpPosition[] memory lbpPositions) internal {
-        for (uint256 i; i < lbpPositions.length; i++) {
-            IUniswapV3Pool(poolAddress).mint(address(this), lbpPositions[i].tickLower, lbpPositions[i].tickUpper, lbpPositions[i].liquidity, "");
-        }
-    }
-
-    /// @dev Handles incoming currency transfers for buy orders; if WETH is the currency the caller has the option to send native-ETH
-    /// @param orderSize The total size of the order in the currency
-    /// @param trueOrderSize The actual amount being used for the swap after fees
-    function _handleIncomingCurrency(uint256 orderSize, uint256 trueOrderSize) internal {
-        if (currency == WETH && msg.value > 0) {
-            if (msg.value != orderSize) {
-                revert EthAmountMismatch();
-            }
-
-            if (msg.value < MIN_ORDER_SIZE) {
-                revert EthAmountTooSmall();
-            }
-
-            IWETH(WETH).deposit{value: trueOrderSize}();
-            IWETH(WETH).approve(swapRouter, trueOrderSize);
-        } else {
-            // Ensure ETH is not sent with a non-ETH pair
-            if (msg.value != 0) {
-                revert EthTransferInvalid();
-            }
-
-            uint256 beforeBalance = IERC20(currency).balanceOf(address(this));
-            IERC20(currency).safeTransferFrom(msg.sender, address(this), orderSize);
-            uint256 afterBalance = IERC20(currency).balanceOf(address(this));
-
-            if ((afterBalance - beforeBalance) != orderSize) {
-                revert ERC20TransferAmountMismatch();
-            }
-
-            IERC20(currency).approve(swapRouter, trueOrderSize);
-        }
-    }
-
-    /// @dev Handles sending ETH and ERC20 payouts and refunds to recipients
-    /// @param orderPayout The amount of currency to pay out
-    /// @param recipient The address to receive the payout
-    function _handlePayout(uint256 orderPayout, address recipient) internal {
-        if (currency == WETH) {
-            Address.sendValue(payable(recipient), orderPayout);
-        } else {
-            IERC20(currency).safeTransfer(recipient, orderPayout);
-        }
-    }
-
-    /// @dev Handles calculating and depositing fees to an escrow protocol rewards contract
-    function _handleTradeRewards(uint256 totalValue, address _tradeReferrer) internal {
-        if (_tradeReferrer == address(0)) {
-            _tradeReferrer = protocolRewardRecipient;
-        }
-
-        uint256 tokenCreatorFee = _calculateReward(totalValue, TOKEN_CREATOR_FEE_BPS);
-        uint256 platformReferrerFee = _calculateReward(totalValue, PLATFORM_REFERRER_FEE_BPS);
-        uint256 tradeReferrerFee = _calculateReward(totalValue, TRADE_REFERRER_FEE_BPS);
-        uint256 protocolFee = totalValue - tokenCreatorFee - platformReferrerFee - tradeReferrerFee;
-
-        if (currency == WETH) {
-            address[] memory recipients = new address[](4);
-            uint256[] memory amounts = new uint256[](4);
-            bytes4[] memory reasons = new bytes4[](4);
-
-            recipients[0] = payoutRecipient;
-            amounts[0] = tokenCreatorFee;
-            reasons[0] = bytes4(keccak256("COIN_CREATOR_REWARD"));
-
-            recipients[1] = platformReferrer;
-            amounts[1] = platformReferrerFee;
-            reasons[1] = bytes4(keccak256("COIN_PLATFORM_REFERRER_REWARD"));
-
-            recipients[2] = _tradeReferrer;
-            amounts[2] = tradeReferrerFee;
-            reasons[2] = bytes4(keccak256("COIN_TRADE_REFERRER_REWARD"));
-
-            recipients[3] = protocolRewardRecipient;
-            amounts[3] = protocolFee;
-            reasons[3] = bytes4(keccak256("COIN_PROTOCOL_REWARD"));
-
-            IProtocolRewards(protocolRewards).depositBatch{value: totalValue}(recipients, amounts, reasons, "");
-        }
-
-        if (currency != WETH) {
-            IERC20(currency).safeTransfer(payoutRecipient, tokenCreatorFee);
-            IERC20(currency).safeTransfer(platformReferrer, platformReferrerFee);
-            IERC20(currency).safeTransfer(_tradeReferrer, tradeReferrerFee);
-            IERC20(currency).safeTransfer(protocolRewardRecipient, protocolFee);
-        }
-
-        emit CoinTradeRewards(
-            payoutRecipient,
-            platformReferrer,
-            _tradeReferrer,
-            protocolRewardRecipient,
-            tokenCreatorFee,
-            platformReferrerFee,
-            tradeReferrerFee,
-            protocolFee,
-            currency
-        );
-    }
-
-    /// @dev Collects and distributes accrued fees from all LP positions
-    function _handleMarketRewards() internal returns (MarketRewards memory) {
-        uint256 totalAmountToken0;
-        uint256 totalAmountToken1;
-        uint256 amount0;
-        uint256 amount1;
-
-        bool isCoinToken0 = address(this) < currency;
-        LpPosition[] memory positions = CoinSetup.calculatePositions(isCoinToken0, poolConfiguration);
-
-        for (uint256 i; i < positions.length; i++) {
-            // Must burn to update the collect mapping on the pool
-            IUniswapV3Pool(poolAddress).burn(positions[i].tickLower, positions[i].tickUpper, 0);
-
-            (amount0, amount1) = IUniswapV3Pool(poolAddress).collect(
-                address(this),
-                positions[i].tickLower,
-                positions[i].tickUpper,
-                type(uint128).max,
-                type(uint128).max
-            );
-
-            totalAmountToken0 += amount0;
-            totalAmountToken1 += amount1;
-        }
-
-        address token0 = currency < address(this) ? currency : address(this);
-        address token1 = currency < address(this) ? address(this) : currency;
-
-        MarketRewards memory rewards;
-
-        rewards = _transferMarketRewards(token0, totalAmountToken0, rewards);
-        rewards = _transferMarketRewards(token1, totalAmountToken1, rewards);
-
-        emit CoinMarketRewards(payoutRecipient, platformReferrer, protocolRewardRecipient, currency, rewards);
-
-        return rewards;
-    }
-
-    function _transferMarketRewards(address token, uint256 totalAmount, MarketRewards memory rewards) internal returns (MarketRewards memory) {
-        if (totalAmount > 0) {
-            address dopplerRecipient = IAirlock(airlock).owner();
-            uint256 dopplerPayout = _calculateReward(totalAmount, DOPPLER_MARKET_REWARD_BPS);
-            uint256 creatorPayout = _calculateReward(totalAmount, CREATOR_MARKET_REWARD_BPS);
-            uint256 platformReferrerPayout = _calculateReward(totalAmount, PLATFORM_REFERRER_MARKET_REWARD_BPS);
-            uint256 protocolPayout = totalAmount - creatorPayout - platformReferrerPayout - dopplerPayout;
-
-            if (token == WETH) {
-                IWETH(WETH).withdraw(totalAmount);
-
-                rewards.totalAmountCurrency = totalAmount;
-                rewards.creatorPayoutAmountCurrency = creatorPayout;
-                rewards.platformReferrerAmountCurrency = platformReferrerPayout;
-                rewards.protocolAmountCurrency = protocolPayout;
-
-                address[] memory recipients = new address[](4);
-                recipients[0] = payoutRecipient;
-                recipients[1] = platformReferrer;
-                recipients[2] = protocolRewardRecipient;
-                recipients[3] = dopplerRecipient;
-
-                uint256[] memory amounts = new uint256[](4);
-                amounts[0] = rewards.creatorPayoutAmountCurrency;
-                amounts[1] = rewards.platformReferrerAmountCurrency;
-                amounts[2] = rewards.protocolAmountCurrency;
-                amounts[3] = dopplerPayout;
-
-                bytes4[] memory reasons = new bytes4[](4);
-                reasons[0] = bytes4(keccak256("COIN_CREATOR_MARKET_REWARD"));
-                reasons[1] = bytes4(keccak256("COIN_PLATFORM_REFERRER_MARKET_REWARD"));
-                reasons[2] = bytes4(keccak256("COIN_PROTOCOL_MARKET_REWARD"));
-                reasons[3] = bytes4(keccak256("COIN_DOPPLER_MARKET_REWARD"));
-
-                IProtocolRewards(protocolRewards).depositBatch{value: totalAmount}(recipients, amounts, reasons, "");
-                IProtocolRewards(protocolRewards).withdrawFor(dopplerRecipient, dopplerPayout);
-            } else if (token == address(this)) {
-                rewards.totalAmountCoin = totalAmount;
-                rewards.creatorPayoutAmountCoin = creatorPayout;
-                rewards.platformReferrerAmountCoin = platformReferrerPayout;
-                rewards.protocolAmountCoin = protocolPayout;
-
-                _transfer(address(this), payoutRecipient, rewards.creatorPayoutAmountCoin);
-                _transfer(address(this), platformReferrer, rewards.platformReferrerAmountCoin);
-                _transfer(address(this), protocolRewardRecipient, rewards.protocolAmountCoin);
-                _transfer(address(this), dopplerRecipient, dopplerPayout);
-            } else {
-                rewards.totalAmountCurrency = totalAmount;
-                rewards.creatorPayoutAmountCurrency = creatorPayout;
-                rewards.platformReferrerAmountCurrency = platformReferrerPayout;
-                rewards.protocolAmountCurrency = protocolPayout;
-
-                IERC20(currency).safeTransfer(payoutRecipient, creatorPayout);
-                IERC20(currency).safeTransfer(platformReferrer, platformReferrerPayout);
-                IERC20(currency).safeTransfer(protocolRewardRecipient, protocolPayout);
-                IERC20(currency).safeTransfer(dopplerRecipient, dopplerPayout);
-            }
-        }
-
-        return rewards;
-    }
-
-    /// @dev Utility for computing amounts in basis points.
-    function _calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
-        return (amount * bps) / 10_000;
-    }
 }

package/src/ZoraFactoryImpl.sol

@@ -9,11 +9,17 @@ import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.s
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {CoinConfigurationVersions} from "./libs/CoinConfigurationVersions.sol";
-
+import {ISwapRouter} from "./interfaces/ISwapRouter.sol";
+import {IWETH} from "./interfaces/IWETH.sol";
 import {IZoraFactory} from "./interfaces/IZoraFactory.sol";
+import {IHasAfterCoinDeploy} from "./hooks/BaseCoinDeployHook.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {Coin} from "./Coin.sol";
+import {ICoin} from "./interfaces/ICoin.sol";
+import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
+import {ContractVersionBase} from "./version/ContractVersionBase.sol";
 
-contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable {
+contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgradeable, OwnableUpgradeable, IHasContractName, ContractVersionBase {
     using SafeERC20 for IERC20;
 
     /// @notice The coin contract implementation address
@@ -23,15 +29,7 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         coinImpl = _coinImpl;
     }
 
-    /// @notice Creates a new 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 Uniswap v3 pool; `abi.encode(address currency, int24 tickLower, int24 tickUpper, uint16 numDiscoveryPositions, uint256 maxDiscoverySupplyShare)`
-    /// @param platformReferrer The address of the platform referrer
-    /// @param orderSize The order size for the first buy; must match msg.value for ETH/WETH pairs
+    /// @inheritdoc IZoraFactory
     function deploy(
         address payoutRecipient,
         address[] memory owners,
@@ -42,40 +40,39 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         address platformReferrer,
         uint256 orderSize
     ) public payable nonReentrant returns (address, uint256) {
-        bytes32 salt = _generateSalt(payoutRecipient, uri);
-
-        Coin coin = Coin(payable(Clones.cloneDeterministic(coinImpl, salt)));
-
-        coin.initialize(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
+        Coin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
 
         uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
 
-        emit CoinCreated(
-            msg.sender,
-            payoutRecipient,
-            coin.platformReferrer(),
-            coin.currency(),
-            uri,
-            name,
-            symbol,
-            address(coin),
-            coin.poolAddress(),
-            coin.contractVersion()
-        );
-
         return (address(coin), coinsPurchased);
     }
 
-    /// @notice Creates a new 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 platformReferrer The address to receive platform referral rewards
-    /// @param currency The address of the trading currency; address(0) for ETH/WETH
-    /// @param tickLower The lower tick for the Uniswap V3 LP position; ignored for ETH/WETH pairs
-    /// @param orderSize The order size for the first buy; must match msg.value for ETH/WETH pairs
+    /// @inheritdoc IZoraFactory
+    function deployWithHook(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address hook,
+        bytes calldata hookData
+    ) public payable nonReentrant returns (address coin, bytes memory hookDataOut) {
+        coin = address(_createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer));
+
+        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();
+        }
+    }
+
+    /// @inheritdoc IZoraFactory
     function deploy(
         address payoutRecipient,
         address[] memory owners,
@@ -87,16 +84,30 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         int24 tickLower,
         uint256 orderSize
     ) public payable nonReentrant returns (address, uint256) {
+        bytes memory poolConfig = abi.encode(CoinConfigurationVersions.LEGACY_POOL_VERSION, currency, tickLower);
+
+        Coin coin = _createAndInitializeCoin(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
+
+        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
+
+        return (address(coin), coinsPurchased);
+    }
+
+    function _createAndInitializeCoin(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer
+    ) internal returns (Coin) {
         bytes32 salt = _generateSalt(payoutRecipient, uri);
 
         Coin coin = Coin(payable(Clones.cloneDeterministic(coinImpl, salt)));
 
-        bytes memory poolConfig = abi.encode(CoinConfigurationVersions.LEGACY_POOL_VERSION, currency, tickLower);
-
         coin.initialize(payoutRecipient, owners, uri, name, symbol, poolConfig, platformReferrer);
 
-        uint256 coinsPurchased = _handleFirstOrder(coin, orderSize);
-
         emit CoinCreated(
             msg.sender,
             payoutRecipient,
@@ -110,7 +121,7 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
             coin.contractVersion()
         );
 
-        return (address(coin), coinsPurchased);
+        return coin;
     }
 
     /// @dev Generates a unique salt for deterministic deployment
@@ -182,7 +193,24 @@ contract ZoraFactoryImpl is IZoraFactory, UUPSUpgradeable, ReentrancyGuardUpgrad
         return ERC1967Utils.getImplementation();
     }
 
+    /// @inheritdoc IHasContractName
+    function contractName() public pure override returns (string memory) {
+        return "ZoraCoinFactory";
+    }
+
     /// @dev Authorizes an upgrade to a new implementation
     /// @param newImpl The new implementation address
-    function _authorizeUpgrade(address newImpl) internal override onlyOwner {}
+    function _authorizeUpgrade(address newImpl) internal override onlyOwner {
+        // 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())) {
+                revert UpgradeToMismatchedContractName(contractName(), name);
+            }
+        } catch {}
+    }
+
+    function _equals(string memory a, string memory b) internal pure returns (bool) {
+        return (keccak256(bytes(a)) == keccak256(bytes(b)));
+    }
 }