@zoralabs/coins 0.9.0 → 1.0.0

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

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+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 {
+    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
+    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
+        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 ICoin.InvalidPoolVersion();
+        }
+    }
+}

package/src/libs/CoinSetupV3.sol

@@ -2,14 +2,14 @@
 pragma solidity ^0.8.23;
 
 import {PoolConfiguration} from "../interfaces/ICoin.sol";
-import {CoinLegacy} from "./CoinLegacy.sol";
 import {CoinDopplerUniV3} from "./CoinDopplerUniV3.sol";
 import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
 import {LpPosition} from "../types/LpPosition.sol";
 import {IUniswapV3Factory} from "../interfaces/IUniswapV3Factory.sol";
 import {MarketConstants} from "./MarketConstants.sol";
 import {IUniswapV3Pool} from "../interfaces/IUniswapV3Pool.sol";
-
+import {ICoin} from "../interfaces/ICoin.sol";
+import {CoinCommon} from "./CoinCommon.sol";
 struct UniV3Config {
     address weth;
     address v3Factory;
@@ -24,75 +24,12 @@ struct CoinV3Config {
 }
 
 library CoinSetupV3 {
-    error InvalidPoolVersion();
-
-    function setupPool(
-        bytes memory poolConfig_,
-        UniV3Config memory uniswapV3Config,
-        address coin
-    ) internal returns (address currency, address poolAddress, PoolConfiguration memory poolConfiguration) {
-        // Extract version and currency from pool config
-        (uint8 version, address currency_) = abi.decode(poolConfig_, (uint8, address));
-
-        // Store the currency, defaulting to WETH if address(0)
-        currency = currency_ == address(0) ? uniswapV3Config.weth : currency_;
-
-        // Sort token addresses for Uniswap V3 pool creation
-        bool isCoinToken0 = _sortTokens(coin, currency);
-        address token0 = isCoinToken0 ? coin : currency;
-        address token1 = isCoinToken0 ? currency : coin;
-
-        // Configure the pool with appropriate version
-        uint160 sqrtPriceX96;
-        (sqrtPriceX96, poolConfiguration) = setupPoolWithVersion(version, poolConfig_, isCoinToken0, uniswapV3Config.weth);
-
-        // Create the pool
-        poolAddress = _createPool(token0, token1, sqrtPriceX96, uniswapV3Config.v3Factory);
-    }
-
     /// @dev Deploys the Uniswap V3 pool and mints initial liquidity based on the pool configuration
-    function deployLiquidity(address coin, address currency, PoolConfiguration memory poolConfiguration, address poolAddress) internal {
+    function deployLiquidity(LpPosition[] memory positions, address poolAddress) internal {
         // Calculate and mint positions
-        LpPosition[] memory positions = calculatePositions(coin, currency, poolConfiguration);
         _mintPositions(positions, poolAddress);
     }
 
-    // Helper function to sort tokens and determine if coin is token0
-    function _sortTokens(address coin, address currency) private pure returns (bool isCoinToken0) {
-        return coin < currency;
-    }
-
-    function setupPoolWithVersion(
-        uint8 version,
-        bytes memory poolConfig_,
-        bool isCoinToken0,
-        address weth
-    ) 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) {
-            (sqrtPriceX96, poolConfiguration) = CoinDopplerUniV3.setupPool(isCoinToken0, poolConfig_);
-        } else {
-            revert InvalidPoolVersion();
-        }
-    }
-
-    function calculatePositions(
-        address coin,
-        address currency,
-        PoolConfiguration memory poolConfiguration
-    ) internal pure returns (LpPosition[] memory positions) {
-        // Create the pool
-        bool isCoinToken0 = _sortTokens(coin, currency);
-        if (poolConfiguration.version == CoinConfigurationVersions.LEGACY_POOL_VERSION) {
-            positions = CoinLegacy.calculatePositions(isCoinToken0, poolConfiguration.tickLower, poolConfiguration.tickUpper);
-        } else if (poolConfiguration.version == CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION) {
-            positions = CoinDopplerUniV3.calculatePositions(isCoinToken0, poolConfiguration);
-        } else {
-            revert InvalidPoolVersion();
-        }
-    }
-
     /// @dev Mints the calculated liquidity positions into the Uniswap V3 pool
     function _mintPositions(LpPosition[] memory lbpPositions, address poolAddress) internal {
         for (uint256 i; i < lbpPositions.length; i++) {
@@ -101,7 +38,9 @@ library CoinSetupV3 {
     }
 
     /// @dev Creates the Uniswap V3 pool for the coin/currency pair
-    function _createPool(address token0, address token1, uint160 sqrtPriceX96, address v3Factory) internal returns (address pool) {
+    function createV3Pool(address coin, address currency, bool isCoinToken0, uint160 sqrtPriceX96, address v3Factory) internal returns (address pool) {
+        address token0 = isCoinToken0 ? coin : currency;
+        address token1 = isCoinToken0 ? currency : coin;
         pool = IUniswapV3Factory(v3Factory).createPool(token0, token1, MarketConstants.LP_FEE);
 
         // This pool should be new, if it has already been initialized