@zoralabs/coins 0.7.1 → 1.0.0

package/src/libs/CoinDopplerUniV3.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import {PoolConfiguration} from "../interfaces/ICoin.sol";
 import {TickMath} from "../utils/uniswap/TickMath.sol";
 import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
 import {ICoin} from "../interfaces/ICoin.sol";
@@ -11,13 +10,13 @@ import {FullMath} from "../utils/uniswap/FullMath.sol";
 import {SqrtPriceMath} from "../utils/uniswap/SqrtPriceMath.sol";
 import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
 import {IDopplerErrors} from "../interfaces/IDopplerErrors.sol";
+import {DopplerMath} from "./DopplerMath.sol";
+import {PoolConfiguration} from "../types/PoolConfiguration.sol";
 
 library CoinDopplerUniV3 {
     function setupPool(bool isCoinToken0, bytes memory poolConfig_) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
-        (, , int24 tickLower_, int24 tickUpper_, uint16 numDiscoveryPositions_, uint256 maxDiscoverySupplyShare_) = abi.decode(
-            poolConfig_,
-            (uint8, address, int24, int24, uint16, uint256)
-        );
+        (, , int24 tickLower_, int24 tickUpper_, uint16 numDiscoveryPositions_, uint256 maxDiscoverySupplyShare_) = CoinConfigurationVersions
+            .decodeDopplerUniV3(poolConfig_);
 
         require(numDiscoveryPositions_ > 1 && numDiscoveryPositions_ <= 200, IDopplerErrors.NumDiscoveryPositionsOutOfRange());
 
@@ -25,178 +24,27 @@ library CoinDopplerUniV3 {
             revert IDopplerErrors.MaxShareToBeSoldExceeded(maxDiscoverySupplyShare_, MarketConstants.WAD);
         }
 
-        int24 savedTickLower = isCoinToken0 ? tickLower_ : -tickUpper_;
-        int24 savedTickUpper = isCoinToken0 ? tickUpper_ : -tickLower_;
+        uint256[] memory maxDiscoverySupplyShare = new uint256[](1);
+        uint16[] memory numDiscoveryPositions = new uint16[](1);
+        int24[] memory savedTickLower = new int24[](1);
+        int24[] memory savedTickUpper = new int24[](1);
 
-        sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? savedTickLower : savedTickUpper);
+        maxDiscoverySupplyShare[0] = maxDiscoverySupplyShare_;
+        numDiscoveryPositions[0] = numDiscoveryPositions_;
+        savedTickLower[0] = isCoinToken0 ? tickLower_ : -tickUpper_;
+        savedTickUpper[0] = isCoinToken0 ? tickUpper_ : -tickLower_;
+
+        sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? savedTickLower[0] : savedTickUpper[0]);
 
         poolConfiguration = PoolConfiguration({
             version: CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+            fee: MarketConstants.LP_FEE,
+            tickSpacing: MarketConstants.TICK_SPACING,
             tickLower: savedTickLower,
             tickUpper: savedTickUpper,
-            numPositions: numDiscoveryPositions_,
-            maxDiscoverySupplyShare: maxDiscoverySupplyShare_
+            numPositions: numDiscoveryPositions_ + 1, // Add one for the final tail position
+            maxDiscoverySupplyShare: maxDiscoverySupplyShare,
+            numDiscoveryPositions: numDiscoveryPositions
         });
     }
-
-    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
-        positions = new LpPosition[](poolConfiguration.numPositions);
-
-        uint256 discoverySupply = FullMath.mulDiv(MarketConstants.POOL_LAUNCH_SUPPLY, poolConfiguration.maxDiscoverySupplyShare, MarketConstants.WAD);
-
-        (positions, discoverySupply) = calculateLogNormalDistribution(
-            poolConfiguration.tickLower,
-            poolConfiguration.tickUpper,
-            MarketConstants.TICK_SPACING,
-            isCoinToken0,
-            discoverySupply,
-            // Populate all positions before the last position (the tail position)
-            poolConfiguration.numPositions - 1, // Only discovery positions
-            positions
-        );
-
-        uint256 tailSupply = MarketConstants.POOL_LAUNCH_SUPPLY - discoverySupply;
-
-        // Calculate the tail position (the last position in the array)
-        positions[poolConfiguration.numPositions - 1] = calculateLpTail(
-            poolConfiguration.tickLower,
-            poolConfiguration.tickUpper,
-            isCoinToken0,
-            tailSupply,
-            MarketConstants.TICK_SPACING
-        );
-    }
-
-    /// @notice Calculates the distribution of liquidity positions across tick ranges.
-    /// @dev For example, with 1000 tokens and 10 bins starting at tick 0:
-    ///      - Creates positions: [0,10], [1,10], [2,10], ..., [9,10]
-    ///      - Each position gets an equal share of tokens (100 tokens each)
-    ///      This creates a linear distribution of liquidity across the tick range
-    /// @dev Changed in DopplerUniswapV3:
-    ///      - Added `LpPosition[] memory newPositions` as an input parameter, removing the internal allocation (`new LpPosition[](totalPositions + 1)`).
-    ///      - Removed the calculation and accumulation of the `reserves` variable entirely.
-    ///      - Return value changed from `(LpPosition[] memory, uint256)` (positions, reserves) to `(LpPosition[] memory, uint256)` (positions, totalAssetsSold).
-    /// @param tickLower The lower tick of the LP range set
-    /// @param tickUpper The upper tick of the LP range set
-    /// @param tickSpacing The tick spacing of the LP range set
-    /// @param isToken0 Whether the base asset is the token0 of the pair
-    /// @param discoverySupply The total supply of the base asset to be sold
-    /// @param totalPositions The total number of positions in the LP range set
-    /// @param newPositions The array of new positions to be created
-    /// @return newPositions The array of new positions to be created
-    /// @return totalAssetsSold The total assets used in the LP range set
-    function calculateLogNormalDistribution(
-        int24 tickLower,
-        int24 tickUpper,
-        int24 tickSpacing,
-        bool isToken0,
-        uint256 discoverySupply,
-        uint16 totalPositions,
-        LpPosition[] memory newPositions
-    ) internal pure returns (LpPosition[] memory, uint256) {
-        int24 farTick = isToken0 ? tickUpper : tickLower;
-        int24 closeTick = isToken0 ? tickLower : tickUpper;
-
-        int24 spread = tickUpper - tickLower;
-
-        uint160 farSqrtPriceX96 = TickMath.getSqrtPriceAtTick(farTick);
-        uint256 amountPerPosition = FullMath.mulDiv(discoverySupply, MarketConstants.WAD, totalPositions * MarketConstants.WAD);
-        uint256 totalAssetsSold;
-
-        for (uint256 i; i < totalPositions; i++) {
-            // calculate the ticks position * 1/n to optimize the division
-            int24 startingTick = isToken0
-                ? closeTick + int24(uint24(FullMath.mulDiv(i, uint256(uint24(spread)), totalPositions)))
-                : closeTick - int24(uint24(FullMath.mulDiv(i, uint256(uint24(spread)), totalPositions)));
-
-            // round the tick to the nearest bin
-            startingTick = alignTickToTickSpacing(isToken0, startingTick, tickSpacing);
-
-            if (startingTick != farTick) {
-                uint160 startingSqrtPriceX96 = TickMath.getSqrtPriceAtTick(startingTick);
-
-                // if discoverySupply is 0, we skip the liquidity calculation as we are burning max liquidity
-                // in each position
-                uint128 liquidity;
-                if (discoverySupply != 0) {
-                    liquidity = isToken0
-                        ? LiquidityAmounts.getLiquidityForAmount0(startingSqrtPriceX96, farSqrtPriceX96, amountPerPosition)
-                        : LiquidityAmounts.getLiquidityForAmount1(farSqrtPriceX96, startingSqrtPriceX96, amountPerPosition);
-
-                    totalAssetsSold += (
-                        isToken0
-                            ? SqrtPriceMath.getAmount0Delta(startingSqrtPriceX96, farSqrtPriceX96, liquidity, true)
-                            : SqrtPriceMath.getAmount1Delta(farSqrtPriceX96, startingSqrtPriceX96, liquidity, true)
-                    );
-                }
-
-                newPositions[i] = LpPosition({
-                    tickLower: farSqrtPriceX96 < startingSqrtPriceX96 ? farTick : startingTick,
-                    tickUpper: farSqrtPriceX96 < startingSqrtPriceX96 ? startingTick : farTick,
-                    liquidity: liquidity
-                });
-            }
-        }
-
-        require(totalAssetsSold <= discoverySupply, IDopplerErrors.CannotMintZeroLiquidity());
-
-        return (newPositions, totalAssetsSold);
-    }
-
-    /// @notice Calculates the final LP position that extends from the far tick to the pool's min/max tick
-    /// @dev This position ensures price equivalence between Uniswap v2 and v3 pools beyond the LBP range
-    /// @dev Changed in DopplerUniswapV3:
-    ///      - Removed parameters: `id`, `reserves`
-    ///      - Liquidity calculation is based *solely* on the provided `tailSupply` within the calculated tail tick range using `LiquidityAmounts.getLiquidityForAmount0` or `getLiquidityForAmount1`.
-    function calculateLpTail(
-        int24 tickLower,
-        int24 tickUpper,
-        bool isToken0,
-        uint256 tailSupply,
-        int24 tickSpacing
-    ) internal pure returns (LpPosition memory lpTail) {
-        int24 posTickLower = isToken0 ? tickUpper : alignTickToTickSpacing(false, TickMath.MIN_TICK, tickSpacing);
-        int24 posTickUpper = isToken0 ? alignTickToTickSpacing(true, TickMath.MAX_TICK, tickSpacing) : tickLower;
-
-        require(posTickLower < posTickUpper, IDopplerErrors.InvalidTickRangeMisordered(posTickLower, posTickUpper));
-
-        // Calculate the sqrtPrices for the tail range boundaries
-        uint160 sqrtPriceA = TickMath.getSqrtPriceAtTick(posTickLower);
-        uint160 sqrtPriceB = TickMath.getSqrtPriceAtTick(posTickUpper);
-
-        // Calculate liquidity only based on the tail range supply
-        uint128 lpTailLiquidity = isToken0
-            ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceA, sqrtPriceB, tailSupply)
-            : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceA, sqrtPriceB, tailSupply);
-
-        lpTail = LpPosition({tickLower: posTickLower, tickUpper: posTickUpper, liquidity: lpTailLiquidity});
-    }
-
-    /// @notice Aligns a tick to the nearest tick spacing
-    /// @dev The tickSpacing parameter cannot be zero
-    /// @param isToken0 Whether the base asset is the token0 of the pair
-    /// @param tick The tick to align
-    /// @param tickSpacing The tick spacing of the pair
-    /// @return alignedTick The aligned tick
-    function alignTickToTickSpacing(bool isToken0, int24 tick, int24 tickSpacing) internal pure returns (int24) {
-        if (isToken0) {
-            // Round down if isToken0
-            if (tick < 0) {
-                // If the tick is negative, we round up (negatively) the negative result to round down
-                return ((tick - tickSpacing + 1) / tickSpacing) * tickSpacing;
-            } else {
-                // Else if positive, we simply round down
-                return (tick / tickSpacing) * tickSpacing;
-            }
-        } else {
-            // Round up if isToken1
-            if (tick < 0) {
-                // If the tick is negative, we round down the negative result to round up
-                return (tick / tickSpacing) * tickSpacing;
-            } else {
-                // Else if positive, we simply round up
-                return ((tick + tickSpacing - 1) / tickSpacing) * tickSpacing;
-            }
-        }
-    }
 }

package/src/libs/CoinRewards.sol

@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IProtocolRewards} from "../interfaces/IProtocolRewards.sol";
+import {ICoin} from "../interfaces/ICoin.sol";
+import {CoinConstants} from "./CoinConstants.sol";
+import {IWETH} from "../interfaces/IWETH.sol";
+
+struct CoinConfig {
+    address protocolRewardRecipient;
+    address platformReferrer;
+    address payoutRecipient;
+    address protocolRewards;
+}
+
+library CoinRewards {
+    using SafeERC20 for IERC20;
+
+    /// @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, address currency, address weth) 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, CoinConfig memory coinConfig, address currency, IWETH weth) internal {
+        address protocolRewardRecipient = coinConfig.protocolRewardRecipient;
+        address platformReferrer = coinConfig.platformReferrer;
+        address payoutRecipient = coinConfig.payoutRecipient;
+        IProtocolRewards protocolRewards = IProtocolRewards(coinConfig.protocolRewards);
+
+        if (_tradeReferrer == address(0)) {
+            _tradeReferrer = protocolRewardRecipient;
+        }
+
+        uint256 tokenCreatorFee = calculateReward(totalValue, CoinConstants.TOKEN_CREATOR_FEE_BPS);
+        uint256 platformReferrerFee = calculateReward(totalValue, CoinConstants.PLATFORM_REFERRER_FEE_BPS);
+        uint256 tradeReferrerFee = calculateReward(totalValue, CoinConstants.TRADE_REFERRER_FEE_BPS);
+        uint256 protocolFee = totalValue - tokenCreatorFee - platformReferrerFee - tradeReferrerFee;
+
+        if (currency == address(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 != address(weth)) {
+            IERC20(currency).safeTransfer(payoutRecipient, tokenCreatorFee);
+            IERC20(currency).safeTransfer(platformReferrer, platformReferrerFee);
+            IERC20(currency).safeTransfer(_tradeReferrer, tradeReferrerFee);
+            IERC20(currency).safeTransfer(protocolRewardRecipient, protocolFee);
+        }
+
+        emit ICoin.CoinTradeRewards(
+            payoutRecipient,
+            platformReferrer,
+            _tradeReferrer,
+            protocolRewardRecipient,
+            tokenCreatorFee,
+            platformReferrerFee,
+            tradeReferrerFee,
+            protocolFee,
+            currency
+        );
+    }
+
+    function calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
+        return (amount * bps) / 10_000;
+    }
+
+    function transferBothRewards(
+        address token0,
+        uint256 totalAmountToken0,
+        address token1,
+        uint256 totalAmountToken1,
+        address coin,
+        CoinConfig memory coinConfig,
+        address currency,
+        IWETH weth,
+        address doppler
+    ) internal returns (ICoin.MarketRewards memory rewards) {
+        rewards = transferMarketRewards(token0, currency, totalAmountToken0, rewards, coin, coinConfig, weth, doppler);
+        rewards = transferMarketRewards(token1, currency, totalAmountToken1, rewards, coin, coinConfig, weth, doppler);
+    }
+
+    struct Distribution {
+        bool isCurrency;
+        uint256 totalAmount;
+        uint256 creatorPayout;
+        uint256 platformReferrerPayout;
+        uint256 protocolPayout;
+    }
+
+    function transferMarketRewards(
+        address token,
+        address currency,
+        uint256 totalAmount,
+        ICoin.MarketRewards memory rewards,
+        address coin,
+        CoinConfig memory coinConfig,
+        IWETH weth,
+        address dopplerRecipient
+    ) internal returns (ICoin.MarketRewards memory) {
+        address payoutRecipient = coinConfig.payoutRecipient;
+        address platformReferrer = coinConfig.platformReferrer;
+        address protocolRewardRecipient = coinConfig.protocolRewardRecipient;
+        address protocolRewards = coinConfig.protocolRewards;
+
+        if (totalAmount > 0) {
+            uint256 dopplerPayout = calculateReward(totalAmount, CoinConstants.DOPPLER_MARKET_REWARD_BPS);
+            uint256 creatorPayout = calculateReward(totalAmount, CoinConstants.CREATOR_MARKET_REWARD_BPS);
+            uint256 platformReferrerPayout = calculateReward(totalAmount, CoinConstants.PLATFORM_REFERRER_MARKET_REWARD_BPS);
+            uint256 protocolPayout = totalAmount - creatorPayout - platformReferrerPayout - dopplerPayout;
+
+            bool isCurrency = token == currency;
+
+            if (token == address(weth)) {
+                IWETH(weth).withdraw(totalAmount);
+
+                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] = creatorPayout;
+                amounts[1] = platformReferrerPayout;
+                amounts[2] = protocolPayout;
+                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 (!isCurrency) {
+                    IERC20(coin).safeTransfer(payoutRecipient, creatorPayout);
+                    IERC20(coin).safeTransfer(platformReferrer, platformReferrerPayout);
+                    IERC20(coin).safeTransfer(protocolRewardRecipient, protocolPayout);
+                    IERC20(coin).safeTransfer(dopplerRecipient, dopplerPayout);
+                } else {
+                    IERC20(currency).safeTransfer(payoutRecipient, creatorPayout);
+                    IERC20(currency).safeTransfer(platformReferrer, platformReferrerPayout);
+                    IERC20(currency).safeTransfer(protocolRewardRecipient, protocolPayout);
+                    IERC20(currency).safeTransfer(dopplerRecipient, dopplerPayout);
+                }
+            }
+
+            if (isCurrency) {
+                rewards.totalAmountCurrency = totalAmount;
+                rewards.creatorPayoutAmountCurrency = creatorPayout;
+                rewards.platformReferrerAmountCurrency = platformReferrerPayout;
+                rewards.protocolAmountCurrency = protocolPayout;
+            } else {
+                rewards.totalAmountCoin = totalAmount;
+                rewards.creatorPayoutAmountCoin = creatorPayout;
+                rewards.platformReferrerAmountCoin = platformReferrerPayout;
+                rewards.protocolAmountCoin = protocolPayout;
+            }
+        }
+
+        return rewards;
+    }
+}

package/src/libs/CoinRewardsV4.sol

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {V4Liquidity} from "./V4Liquidity.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {IHasRewardsRecipients} from "../interfaces/ICoin.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {ICoin} from "../interfaces/ICoin.sol";
+import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
+import {UniV4SwapToCurrency} from "./UniV4SwapToCurrency.sol";
+import {IHasSwapPath} from "../interfaces/ICoinV4.sol";
+
+library CoinRewardsV4 {
+    using SafeERC20 for IERC20;
+
+    // creator gets 50% of the total fee
+    uint256 public constant CREATOR_REWARD_BPS = 5000;
+
+    // create referrer gets 15% of the total fee
+    uint256 public constant CREATE_REFERRAL_REWARD_BPS = 1500;
+
+    // trade referrer gets 10% of the total fee
+    uint256 public constant TRADE_REFERRAL_REWARD_BPS = 1500;
+
+    // doppler gets 5% of the total fee
+    uint256 public constant DOPPLER_REWARD_BPS = 500;
+
+    function getTradeReferral(bytes calldata hookData) internal pure returns (address) {
+        return hookData.length > 0 ? abi.decode(hookData, (address)) : address(0);
+    }
+
+    /// @notice Collects fees from LP positions, swaps them to target payout currency, and transfers to hook contract, so
+    /// that they can later be distributed as rewards.
+    /// @param poolManager The pool manager instance
+    /// @param key The pool key
+    /// @param positions The LP positions to collect fees from
+    /// @param payoutSwapPath The swap path to convert fees to target currency
+    /// @return fees0 The amount of fees collected in currency0
+    /// @return fees1 The amount of fees collected in currency1
+    /// @return receivedCurrency The final currency after swapping
+    /// @return receivedAmount The final amount after swapping
+    function collectFeesAndConvertToPayout(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        LpPosition[] storage positions,
+        IHasSwapPath.PayoutSwapPath memory payoutSwapPath
+    ) internal returns (int128 fees0, int128 fees1, Currency receivedCurrency, uint128 receivedAmount) {
+        // Step 1: Collect accrued fees from all LP positions in both token0 and token1
+        (fees0, fees1) = V4Liquidity.collectFees(poolManager, key, positions);
+
+        // Step 2: Swap the collected fees through the specified path to convert them to the target payout currency
+        // This handles multi-hop swaps if needed (e.g. coin -> backingCoin -> backingCoin's currency)
+        (receivedCurrency, receivedAmount) = UniV4SwapToCurrency.swapToPath(
+            poolManager,
+            uint128(fees0),
+            uint128(fees1),
+            payoutSwapPath.currencyIn,
+            payoutSwapPath.path
+        );
+
+        // Step 3: Transfer the final converted currency amount to this contract for distribution
+        // This makes the tokens available for the subsequent reward distribution
+        if (receivedAmount > 0) {
+            poolManager.take(receivedCurrency, address(this), receivedAmount);
+        }
+    }
+
+    /// @notice Distributes collected market fees as rewards to various recipients including creator, referrers, protocol, and doppler
+    /// @dev Calculates reward amounts based on predefined basis points and transfers the specified currency to each recipient
+    /// @param currency The currency token to distribute as rewards (can be native ETH if address is zero)
+    /// @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)
+    function distributeMarketRewards(Currency currency, uint128 fees, IHasRewardsRecipients coin, address tradeReferrer) internal {
+        address payoutRecipient = coin.payoutRecipient();
+        address platformReferrer = coin.platformReferrer();
+        address protocolRewardRecipient = coin.protocolRewardRecipient();
+        address doppler = coin.dopplerFeeRecipient();
+
+        MarketRewards memory rewards = _distributeCurrencyRewards(
+            currency,
+            fees,
+            payoutRecipient,
+            platformReferrer,
+            protocolRewardRecipient,
+            doppler,
+            tradeReferrer
+        );
+
+        IZoraV4CoinHook.MarketRewardsV4 memory marketRewards = IZoraV4CoinHook.MarketRewardsV4({
+            creatorPayoutAmountCurrency: rewards.creatorAmount,
+            creatorPayoutAmountCoin: 0,
+            platformReferrerAmountCurrency: rewards.platformReferrerAmount,
+            platformReferrerAmountCoin: 0,
+            tradeReferrerAmountCurrency: rewards.tradeReferrerAmount,
+            tradeReferrerAmountCoin: 0,
+            protocolAmountCurrency: rewards.protocolAmount,
+            protocolAmountCoin: 0,
+            dopplerAmountCurrency: rewards.dopplerAmount,
+            dopplerAmountCoin: 0
+        });
+
+        emit IZoraV4CoinHook.CoinMarketRewardsV4(
+            address(coin),
+            Currency.unwrap(currency),
+            payoutRecipient,
+            platformReferrer,
+            tradeReferrer,
+            protocolRewardRecipient,
+            doppler,
+            marketRewards
+        );
+    }
+
+    struct MarketRewards {
+        uint256 platformReferrerAmount;
+        uint256 tradeReferrerAmount;
+        uint256 protocolAmount;
+        uint256 creatorAmount;
+        uint256 dopplerAmount;
+    }
+
+    function _distributeCurrencyRewards(
+        Currency currency,
+        uint128 fee,
+        address payoutRecipient,
+        address platformReferrer,
+        address protocolRewardRecipient,
+        address doppler,
+        address tradeReferral
+    ) 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);
+    }
+
+    function _transferCurrency(Currency currency, uint256 amount, address to) internal {
+        if (amount == 0) {
+            return;
+        }
+
+        if (currency.isAddressZero()) {
+            (bool success, ) = payable(to).call{value: amount}("");
+            if (!success) {
+                revert ICoin.EthTransferFailed();
+            }
+        } else {
+            IERC20(Currency.unwrap(currency)).safeTransfer(to, amount);
+        }
+    }
+
+    function _computeMarketRewards(uint128 fee, bool hasTradeReferral, bool hasCreateReferral) internal pure returns (MarketRewards memory rewards) {
+        if (fee == 0) {
+            return rewards;
+        }
+
+        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.protocolAmount = totalAmount - rewards.platformReferrerAmount - rewards.tradeReferrerAmount - rewards.creatorAmount - rewards.dopplerAmount;
+    }
+
+    function calculateReward(uint256 amount, uint256 bps) internal pure returns (uint256) {
+        return (amount * bps) / 10_000;
+    }
+}

package/src/libs/CoinSetup.sol

@@ -1,37 +1,57 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-import {PoolConfiguration} from "../interfaces/ICoin.sol";
-import {CoinLegacy} from "./CoinLegacy.sol";
-import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
+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 {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";
+import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
 
 library CoinSetup {
-    error InvalidPoolVersion();
+    function generatePoolConfig(
+        address coin,
+        bytes memory poolConfig_
+    ) internal pure returns (uint8 version, address currency, uint160 sqrtPriceX96, bool isCoinToken0, PoolConfiguration memory poolConfiguration) {
+        // Extract version and currency from pool config
+        (version, currency) = CoinConfigurationVersions.decodeVersionAndCurrency(poolConfig_);
+
+        isCoinToken0 = CoinCommon.sortTokens(coin, currency);
+
+        (sqrtPriceX96, poolConfiguration) = setupPoolWithVersion(version, poolConfig_, isCoinToken0);
+    }
+
+    function buildPoolKey(address coin, address currency, bool isCoinToken0, IHooks hooks) internal pure returns (PoolKey memory poolKey) {
+        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
+        });
+    }
 
     function setupPoolWithVersion(
         uint8 version,
         bytes memory poolConfig_,
-        bool isCoinToken0,
-        address weth
+        bool isCoinToken0
     ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
-        if (version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            (sqrtPriceX96, poolConfiguration) = CoinLegacy.setupPool(isCoinToken0, poolConfig_, weth);
-        } else if (version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
+        if (version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
             (sqrtPriceX96, poolConfiguration) = CoinDopplerUniV3.setupPool(isCoinToken0, poolConfig_);
+        } else if (version == CoinConfigurationVersions.DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION) {
+            (sqrtPriceX96, poolConfiguration) = CoinDopplerMultiCurve.setupPool(isCoinToken0, poolConfig_);
         } else {
-            revert InvalidPoolVersion();
-        }
-    }
-
-    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
-        if (poolConfiguration.version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            positions = CoinLegacy.calculatePositions(isCoinToken0, poolConfiguration);
-        } else if (poolConfiguration.version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            positions = CoinDopplerUniV3.calculatePositions(isCoinToken0, poolConfiguration);
-        } else {
-            revert InvalidPoolVersion();
+            revert ICoin.InvalidPoolVersion();
         }
     }
 }