@zoralabs/coins 2.2.1 → 2.3.1

package/src/hooks/deployment/BuySupplyWithV4SwapHook.sol

@@ -0,0 +1,310 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IPoolManager, SwapParams} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {BaseCoinDeployHook} from "./BaseCoinDeployHook.sol";
+import {IUniswapV3SwapCallback} from "../../interfaces/IUniswapV3SwapCallback.sol";
+import {ICoin} from "../../interfaces/ICoin.sol";
+import {ISwapRouter} from "../../interfaces/ISwapRouter.sol";
+import {IZoraFactory} from "../../interfaces/IZoraFactory.sol";
+import {ICoinV3} from "../../interfaces/ICoinV3.sol";
+import {CoinConfigurationVersions} from "../../libs/CoinConfigurationVersions.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+import {Path} from "@zoralabs/shared-contracts/libs/UniswapV3/Path.sol";
+
+/// @title BuySupplyWithV4SwapHook
+/// @notice Hook for purchasing initial coin supply with flexible swap routing
+/// @dev Capabilities:
+///      - ETH → V3 swap → V4 swap → coin (e.g., ETH → ZORA → Creator Coin → Content Coin)
+///      - ETH → V3 swap → coin (e.g., ETH → ZORA for ZORA-backed coin)
+///      - ETH → V4 swap → coin (direct ETH-paired coins)
+///      - ERC20 → V4 swap → coin (e.g., Creator Coins → Content Coin)
+///      - Slippage protection with minAmountOut validation
+///
+///      Limitations:
+///      - V3 swaps only support ETH as input currency
+///      - ERC20 input currencies require pre-approval
+///      - V3 and V4 routes must connect properly (V3 output = V4 input)
+contract BuySupplyWithV4SwapHook is BaseCoinDeployHook {
+    using BalanceDeltaLibrary for BalanceDelta;
+    using SafeERC20 for IERC20;
+    using CurrencyLibrary for Currency;
+    using Path for bytes;
+
+    // ============ STATE VARIABLES ============
+
+    ISwapRouter public immutable swapRouter;
+    IPoolManager public immutable poolManager;
+
+    // ============ STRUCTS ============
+
+    struct InitialSupplyParams {
+        address buyRecipient; // Who gets the coins
+        bytes v3Route; // V3 route from ETH to backing currency
+        PoolKey[] v4Route; // V4 route from backing currency to coin
+        address inputCurrency; // Currency to use for the V3 swap
+        uint256 inputAmount; // Amount of input currency to use for the V3 swap
+        uint256 minAmountOut; // Minimum amount of coins to receive from final swap
+    }
+
+    event BuyInitialSupply(
+        address indexed coin,
+        address indexed recipient,
+        uint256 indexed coinsPurchased,
+        bytes v3Route,
+        PoolKey[] v4Route,
+        address inputCurrency,
+        uint256 inputAmount,
+        uint256 v4SwapInput
+    );
+
+    // ============ ERRORS ============
+
+    error OnlyPoolManager();
+    error InsufficientInputCurrency(uint256 inputAmount, uint256 availableAmount);
+    error V3RouteCannotStartWithInputCurrency();
+    error V3RouteDoesNotConnectToV4RouteStart();
+    error InsufficientOutputAmount();
+
+    // ============ CONSTRUCTOR ============
+
+    constructor(IZoraFactory _factory, address _swapRouter, address _poolManager) BaseCoinDeployHook(_factory) {
+        swapRouter = ISwapRouter(_swapRouter);
+        poolManager = IPoolManager(_poolManager);
+    }
+
+    // ============ MAIN HOOK FUNCTION ============
+
+    /// @notice Hook that buys supply for a coin using V3->V4 two-step swap routing
+    /// @dev Returns abi encoded (uint256 amountCurrency, uint256 coinsPurchased)
+    function _afterCoinDeploy(address, ICoin coin, bytes calldata hookData) internal override returns (bytes memory) {
+        // STEP 1: Decode parameters
+        InitialSupplyParams memory params = abi.decode(hookData, (InitialSupplyParams));
+
+        PoolKey[] memory v4Route = _buildV4RouteToCoin(coin, params.v4Route);
+
+        // STEP 2: Validate routes
+        _validateRoutes(params, v4Route);
+
+        _validateAndTransferInputCurrency(params);
+
+        // STEP 3: Execute V3 swap (inputCurrency -> backing currency)
+        (uint256 currencyAmount, address currencyReceived) = _executeV3Swap(params);
+
+        // STEP 4: Execute V4 swaps if needed, then buy coin
+        uint256 coinAmount = _executeV4Swap(v4Route, currencyAmount, currencyReceived, params.buyRecipient);
+
+        // Validate minimum amount of coins received from final swap
+        require(coinAmount >= params.minAmountOut, InsufficientOutputAmount());
+
+        emit BuyInitialSupply({
+            recipient: params.buyRecipient,
+            coin: address(coin),
+            v3Route: params.v3Route,
+            v4Route: v4Route,
+            inputCurrency: params.inputCurrency,
+            inputAmount: params.inputAmount,
+            v4SwapInput: currencyAmount,
+            coinsPurchased: coinAmount
+        });
+
+        // STEP 5: Return results
+        return abi.encode(currencyAmount, coinAmount);
+    }
+
+    // ============ VALIDATION ============
+
+    function _validateRoutes(InitialSupplyParams memory params, PoolKey[] memory v4Route) internal pure {
+        // Determine what currency should be the input to the V4 route
+        address v4InputCurrency;
+        if (params.v3Route.length == 0) {
+            // No V3 swap - input currency should directly match V4 route start
+            v4InputCurrency = params.inputCurrency;
+        } else {
+            // V3 swap exists - V3 output should match V4 route start
+            v4InputCurrency = _getV3RouteOutputCurrency(params.v3Route);
+        }
+
+        PoolKey memory firstPool = v4Route[0];
+
+        require(
+            v4InputCurrency == Currency.unwrap(firstPool.currency0) || v4InputCurrency == Currency.unwrap(firstPool.currency1),
+            V3RouteDoesNotConnectToV4RouteStart()
+        );
+    }
+
+    function _validateAndTransferInputCurrency(InitialSupplyParams memory params) internal {
+        if (params.inputCurrency == address(0)) {
+            uint256 providedAmount = msg.value;
+
+            require(providedAmount == params.inputAmount, InsufficientInputCurrency(params.inputAmount, providedAmount));
+        } else {
+            uint256 providedAmount = IERC20(params.inputCurrency).allowance(params.buyRecipient, address(this));
+
+            // must be enough allowance to transfer
+            require(providedAmount >= params.inputAmount, InsufficientInputCurrency(params.inputAmount, providedAmount));
+
+            // transfer from the buy recipient to this contract
+            IERC20(params.inputCurrency).safeTransferFrom(params.buyRecipient, address(this), params.inputAmount);
+        }
+    }
+
+    function _buildV4RouteToCoin(ICoin coin, PoolKey[] memory v4Route) internal view returns (PoolKey[] memory fullRoute) {
+        fullRoute = new PoolKey[](v4Route.length + 1);
+
+        for (uint256 i = 0; i < v4Route.length; i++) {
+            fullRoute[i] = v4Route[i];
+        }
+
+        fullRoute[v4Route.length] = coin.getPoolKey();
+    }
+
+    // ============ V3 SWAP LOGIC ============
+
+    function _executeV3Swap(InitialSupplyParams memory params) internal returns (uint256 amountCurrency, address currencyReceived) {
+        if (params.v3Route.length == 0) {
+            // No V3 swap needed - return inputAmount directly
+            return (params.inputAmount, params.inputCurrency);
+        }
+
+        // for v3 swap section, we dont support currently having an input currency other than eth
+        if (params.inputCurrency != address(0)) {
+            revert V3RouteCannotStartWithInputCurrency();
+        }
+
+        // Build swap router call for exactInput
+        ISwapRouter.ExactInputParams memory swapParams = ISwapRouter.ExactInputParams({
+            path: params.v3Route,
+            recipient: address(this),
+            amountIn: params.inputAmount,
+            amountOutMinimum: 0 // For testing - in production should have slippage protection
+        });
+
+        amountCurrency = swapRouter.exactInput{value: params.inputAmount}(swapParams);
+
+        currencyReceived = _getV3RouteOutputCurrency(params.v3Route);
+    }
+
+    function _executeV4Swap(PoolKey[] memory v4Route, uint256 amountIn, address currencyIn, address buyRecipient) internal returns (uint256 amountCoin) {
+        Currency startingCurrency = Currency.wrap(currencyIn);
+        bytes memory data = abi.encode(v4Route, amountIn, startingCurrency, buyRecipient);
+        bytes memory result = poolManager.unlock(data);
+        amountCoin = abi.decode(result, (uint256));
+    }
+
+    /// @notice Callback for V4 swaps through route or coin purchase
+    function unlockCallback(bytes calldata data) external returns (bytes memory) {
+        require(msg.sender == address(poolManager), OnlyPoolManager());
+
+        (PoolKey[] memory v4Route, uint256 amountIn, Currency startingCurrency, address buyRecipient) = abi.decode(
+            data,
+            (PoolKey[], uint256, Currency, address)
+        );
+
+        Currency lastReceivedCurrency = startingCurrency;
+        uint128 lastReceivedAmount = uint128(amountIn);
+        // Execute swaps through the route
+
+        uint128 outputAmount = 0;
+        for (uint256 i = 0; i < v4Route.length; i++) {
+            PoolKey memory poolKey = v4Route[i];
+
+            // Determine swap direction based on current currency
+            bool zeroForOne = lastReceivedCurrency == poolKey.currency0;
+
+            BalanceDelta delta = poolManager.swap(
+                poolKey,
+                SwapParams(zeroForOne, -(int128(lastReceivedAmount)), zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
+                ""
+            );
+
+            // Extract output amount from delta
+            outputAmount = zeroForOne ? uint128(delta.amount1()) : uint128(delta.amount0());
+
+            // Update currentAmount for next iteration
+            lastReceivedAmount = uint128(outputAmount);
+
+            // Update current currency for next swap
+            lastReceivedCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+        }
+
+        // Settle all currency deltas and get final amount
+        _settleDeltas(startingCurrency, lastReceivedCurrency, buyRecipient, amountIn, outputAmount);
+
+        return abi.encode(lastReceivedAmount);
+    }
+
+    /// @notice Helper to decode V4 route data (external for try/catch)
+    function decodeV4RouteData(bytes calldata data) external pure returns (PoolKey[] memory v4Route, uint256 startAmount) {
+        return abi.decode(data, (PoolKey[], uint256));
+    }
+
+    function encodeBuySupplyWithV4SwapHookData(InitialSupplyParams memory params) external pure returns (bytes memory) {
+        return abi.encode(params);
+    }
+
+    function _settleDeltas(Currency inputCurrency, Currency outputCurrency, address to, uint256 inputAmount, uint128 outputAmount) private {
+        // pay the input amount
+        if (inputCurrency.isAddressZero()) {
+            // For ETH, settle with msg.value
+            poolManager.settle{value: inputAmount}();
+        } else {
+            // For ERC20, sync and transfer
+            poolManager.sync(inputCurrency);
+            inputCurrency.transfer(address(poolManager), inputAmount);
+            poolManager.settle();
+        }
+
+        // transfer the output amount to the recipient
+        poolManager.take(outputCurrency, to, outputAmount);
+    }
+
+    // ============ UTILITIES ============
+
+    function _getCoinBackingCurrency(ICoin coin) internal view returns (Currency) {
+        PoolKey memory poolKey = coin.getPoolKey();
+
+        if (Currency.unwrap(poolKey.currency0) == address(coin)) {
+            return poolKey.currency1;
+        }
+        return poolKey.currency0;
+    }
+
+    function _getV3RouteOutputCurrency(bytes memory path) internal pure returns (address tokenOut) {
+        if (path.length == 0) {
+            // if no path, then output currency is eth
+            return address(0);
+        }
+
+        // For a path with multiple pools, we need to traverse to the end
+        // Path format: tokenA + fee + tokenB + fee + tokenC...
+        // We want the final token (tokenC in this example)
+
+        // Follow Uniswap's pattern: traverse the path to find the final token
+        bytes memory currentPath = path;
+
+        // Keep skipping tokens until we reach the final pool
+        while (currentPath.hasMultiplePools()) {
+            currentPath = currentPath.skipToken();
+        }
+
+        // The final segment contains the last pool, decode to get the output token
+        (, tokenOut, ) = currentPath.decodeFirstPool();
+    }
+
+    function _getV3RouteInputCurrency(bytes memory path) internal pure returns (address tokenIn) {
+        if (path.length == 0) {
+            // if no path, then input currency is eth
+            return address(0);
+        }
+
+        // Use Path library to get the input token (first token in the path)
+        (tokenIn, , ) = path.decodeFirstPool();
+    }
+}

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

@@ -97,7 +97,20 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
     /// @notice Thrwon when an invalid config version is provided
     error InvalidConfig();
 
-    /// @notice Creates a new creator coin contract
+    /// @dev Deprecated: use `deployCreatorCoin` instead that has a salt and post-deploy hook specified
+    function deployCreatorCoin(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        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
@@ -105,7 +118,11 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
     /// @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,
@@ -114,8 +131,10 @@ interface IZoraFactory is IDeployedCoinVersionLookup {
         string memory symbol,
         bytes memory poolConfig,
         address platformReferrer,
+        address postDeployHook,
+        bytes calldata postDeployHookData,
         bytes32 coinSalt
-    ) external returns (address);
+    ) 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

package/src/libs/CoinConstants.sol

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

package/src/libs/CoinDopplerMultiCurve.sol

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

package/src/libs/CoinRewardsV4.sol

@@ -33,26 +33,11 @@ import {ICreatorCoinHook} from "../interfaces/ICreatorCoinHook.sol";
 import {IHasCoinType} from "../interfaces/ICoin.sol";
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {ICreatorCoin} from "../interfaces/ICreatorCoin.sol";
+import {CoinConstants} from "./CoinConstants.sol";
 
 library CoinRewardsV4 {
     using SafeERC20 for IERC20;
 
-    // Creator gets 62.5% of market rewards (0.50% of total 1% fee)
-    // Market rewards = 80% of total fee (0.80% of 1%)
-    uint256 public constant CREATOR_REWARD_BPS = 6250;
-
-    // Platform referrer gets 25% of market rewards (0.20% of total 1% fee)
-    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 2500;
-
-    // Trade referrer gets 5% of market rewards (0.04% of total 1% fee)
-    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 500;
-
-    // Doppler gets 1.25% of market rewards (0.01% of total 1% fee)
-    uint256 public constant DOPPLER_REWARD_BPS = 125;
-
-    // LPs get 20% of total fee (0.20% of 1%)
-    uint256 public constant LP_REWARD_BPS = 2000;
-
     function getTradeReferral(bytes calldata hookData) internal pure returns (address) {
         return hookData.length >= 20 ? abi.decode(hookData, (address)) : address(0);
     }
@@ -83,13 +68,16 @@ library CoinRewardsV4 {
 
     /// @dev Computes the LP reward and remaining amount for market rewards from the total amount
     function computeLpReward(uint128 totalBackingAmount) internal pure returns (uint128 lpRewardAmount) {
-        lpRewardAmount = uint128(calculateReward(uint256(totalBackingAmount), LP_REWARD_BPS));
+        lpRewardAmount = uint128(calculateReward(uint256(totalBackingAmount), CoinConstants.LP_REWARD_BPS));
     }
 
     function convertDeltaToPositiveUint128(int256 delta) internal pure returns (uint128) {
         if (delta < 0) {
             revert SafeCast.SafeCastOverflow();
         }
+        if (delta > int256(uint256(type(uint128).max))) {
+            revert SafeCast.SafeCastOverflow();
+        }
         return uint128(uint256(delta));
     }
 
@@ -181,6 +169,7 @@ library CoinRewardsV4 {
     /// @param fees The total amount of fees collected to be distributed
     /// @param coin The coin contract instance that implements IHasRewardsRecipients to get recipient addresses
     /// @param tradeReferrer The address of the trade referrer who should receive trade referral rewards (can be zero address)
+    /// @param coinType The type of coin (Creator or Content) which affects reward distribution percentages
     function distributeMarketRewards(
         Currency currency,
         uint128 fees,
@@ -258,26 +247,30 @@ library CoinRewardsV4 {
     ) internal returns (MarketRewards memory rewards) {
         rewards = _computeMarketRewards(fee, tradeReferral != address(0), platformReferrer != address(0));
 
-        if (platformReferrer != address(0)) {
-            _transferCurrency(currency, rewards.platformReferrerAmount, platformReferrer);
-        }
-        if (tradeReferral != address(0)) {
-            _transferCurrency(currency, rewards.tradeReferrerAmount, tradeReferral);
-        }
-        _transferCurrency(currency, rewards.creatorAmount, payoutRecipient);
-        _transferCurrency(currency, rewards.dopplerAmount, doppler);
-        _transferCurrency(currency, rewards.protocolAmount, protocolRewardRecipient);
+        // Notes on ETH transfer fallback behavior:
+        // - If the platform referrer is immutable; if it is set to an address that cannot receive ETH, it can brick swaps on the coin, as they would revert.
+        // - Both the creator recipient and trade referral are changeable, the former via updating the payout recipient on the coin, and the latter via updating the trade referrer argument when doing a swap;
+        // therefore we do not need to worry about permanently bricking swaps, and don't need a backup recipient.
+        _transferCurrency(currency, rewards.platformReferrerAmount, platformReferrer, protocolRewardRecipient);
+        _transferCurrency(currency, rewards.tradeReferrerAmount, tradeReferral, address(0));
+        _transferCurrency(currency, rewards.creatorAmount, payoutRecipient, address(0));
+        _transferCurrency(currency, rewards.dopplerAmount, doppler, protocolRewardRecipient);
+        _transferCurrency(currency, rewards.protocolAmount, protocolRewardRecipient, address(0));
     }
 
-    function _transferCurrency(Currency currency, uint256 amount, address to) internal {
-        if (amount == 0) {
+    function _transferCurrency(Currency currency, uint256 amount, address to, address backupRecipient) internal {
+        if (amount == 0 || to == address(0)) {
             return;
         }
 
         if (currency.isAddressZero()) {
             (bool success, ) = payable(to).call{value: amount}("");
             if (!success) {
-                revert ICoin.EthTransferFailed();
+                if (backupRecipient == address(0)) {
+                    revert ICoin.EthTransferFailed();
+                } else {
+                    _transferCurrency(currency, amount, backupRecipient, address(0));
+                }
             }
         } else {
             IERC20(Currency.unwrap(currency)).safeTransfer(to, amount);
@@ -290,10 +283,10 @@ library CoinRewardsV4 {
         }
 
         uint256 totalAmount = uint256(fee);
-        rewards.platformReferrerAmount = hasCreateReferral ? calculateReward(totalAmount, CREATE_REFERRAL_REWARD_BPS) : 0;
-        rewards.tradeReferrerAmount = hasTradeReferral ? calculateReward(totalAmount, TRADE_REFERRAL_REWARD_BPS) : 0;
-        rewards.creatorAmount = calculateReward(totalAmount, CREATOR_REWARD_BPS);
-        rewards.dopplerAmount = calculateReward(totalAmount, DOPPLER_REWARD_BPS);
+        rewards.platformReferrerAmount = hasCreateReferral ? calculateReward(totalAmount, CoinConstants.CREATE_REFERRAL_REWARD_BPS) : 0;
+        rewards.tradeReferrerAmount = hasTradeReferral ? calculateReward(totalAmount, CoinConstants.TRADE_REFERRAL_REWARD_BPS) : 0;
+        rewards.creatorAmount = calculateReward(totalAmount, CoinConstants.CREATOR_REWARD_BPS);
+        rewards.dopplerAmount = calculateReward(totalAmount, CoinConstants.DOPPLER_REWARD_BPS);
         rewards.protocolAmount = totalAmount - rewards.platformReferrerAmount - rewards.tradeReferrerAmount - rewards.creatorAmount - rewards.dopplerAmount;
     }
 

package/src/libs/CoinSetup.sol

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