@zoralabs/coins 0.7.1 → 1.0.0

package/src/interfaces/ISwapRouter.sol

@@ -1,38 +1,4 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 pragma solidity ^0.8.0;
 
-import {IUniswapV3SwapCallback} from "./IUniswapV3SwapCallback.sol";
-
-/// @title Router token swapping functionality
-/// @notice Functions for swapping tokens via Uniswap V3
-interface ISwapRouter is IUniswapV3SwapCallback {
-    struct ExactInputSingleParams {
-        address tokenIn;
-        address tokenOut;
-        uint24 fee;
-        address recipient;
-        uint256 amountIn;
-        uint256 amountOutMinimum;
-        uint160 sqrtPriceLimitX96;
-    }
-
-    struct ExactOutputSingleParams {
-        address tokenIn;
-        address tokenOut;
-        uint24 fee;
-        address recipient;
-        uint256 amountOut;
-        uint256 amountInMaximum;
-        uint160 sqrtPriceLimitX96;
-    }
-
-    /// @notice Swaps `amountIn` of one token for as much as possible of another token
-    /// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
-    /// @return amountOut The amount of the received token
-    function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
-
-    /// @notice Swaps as little as possible of one token for `amountOut` of another token
-    /// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
-    /// @return amountIn The amount of the input token
-    function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
-}
+import {ISwapRouter} from "@zoralabs/shared-contracts/interfaces/uniswap/ISwapRouter.sol";

package/src/interfaces/IZoraFactory.sol

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolKeyStruct} from "./ICoin.sol";
+
 interface IZoraFactory {
     /// @notice Emitted when a coin is created
     /// @param caller The msg.sender address
@@ -26,31 +29,118 @@ interface IZoraFactory {
         string version
     );
 
+    /// @notice Emitted when a coin is created
+    /// @param caller The msg.sender address
+    /// @param payoutRecipient The address of the creator payout recipient
+    /// @param platformReferrer The address of the platform referrer
+    /// @param currency The address of the currency
+    /// @param uri The URI of the coin
+    /// @param name The name of the coin
+    /// @param symbol The symbol of the coin
+    /// @param coin The address of the coin
+    /// @param poolKey The uniswap v4 pool key
+    /// @param version The coin contract version
+    event CoinCreatedV4(
+        address indexed caller,
+        address indexed payoutRecipient,
+        address indexed platformReferrer,
+        address currency,
+        string uri,
+        string name,
+        string symbol,
+        address coin,
+        PoolKey poolKey,
+        bytes32 poolKeyHash,
+        string version
+    );
+
     /// @notice Thrown when the amount of ERC20 tokens transferred does not match the expected amount
     error ERC20TransferAmountMismatch();
 
     /// @notice Thrown when ETH is sent with a transaction but the currency is not WETH
     error EthTransferInvalid();
 
-    /// @notice Creates a new coin contract
+    /// @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
+    /// a predictable address.
     /// @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
+    /// @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
+    /// @return coin The address of the deployed coin
+    /// @return postDeployHookDataOut The data returned by the hook
     function deploy(
         address payoutRecipient,
         address[] memory owners,
         string memory uri,
         string memory name,
         string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        address postDeployHook,
+        bytes calldata postDeployHookData,
+        bytes32 coinSalt
+    ) external payable returns (address coin, bytes memory postDeployHookDataOut);
+
+    /// @notice Predicts the address of a coin contract that will be deployed with the given parameters
+    /// @param msgSender The address of the msg.sender
+    /// @param name The name of the coin
+    /// @param symbol The symbol of the coin
+    /// @param poolConfig The pool config
+    /// @param platformReferrer The platform referrer
+    /// @param coinSalt The salt used to deploy the coin
+    /// @return The address of the coin contract
+    function coinAddress(
+        address msgSender,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
+        address platformReferrer,
+        bytes32 coinSalt
+    ) external view returns (address);
+
+    /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
+    function deploy(
+        address payoutRecipient,
+        address[] memory owners,
+        string memory uri,
+        string memory name,
+        string memory symbol,
+        bytes memory poolConfig,
         address platformReferrer,
-        address currency,
-        int24 tickLower,
         uint256 orderSize
     ) external payable returns (address, uint256);
+
+    /// @dev Deprecated: use `deploy` instead that has a salt and hook specified
+    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
+    ) external payable returns (address coin, bytes memory hookDataOut);
+
+    function coinImpl() external view returns (address);
+
+    function implementation() external view returns (address);
+
+    /// @notice Thrown when the hook is invalid
+    error InvalidHook();
+
+    /// @notice Occurs when attempting to upgrade to a contract with a name that doesn't match the current contract's name
+    /// @param currentName The name of the current contract
+    /// @param newName The name of the contract being upgraded to
+    error UpgradeToMismatchedContractName(string currentName, string newName);
+
+    /// @notice Thrown when a method is deprecated
+    error Deprecated();
 }

package/src/interfaces/IZoraV4CoinHook.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {ICoin} from "./ICoin.sol";
+
+interface IZoraV4CoinHook {
+    /// @notice Emitted when a swap is executed.
+    /// @param sender The address of the sender.
+    /// @param swapSender The address of the swap sender.
+    /// @param isTrustedSwapSenderAddress Whether the swap sender is a trusted address. (Based on a registry of trusted addresses)
+    /// @param key The pool key struct to identify the pool.
+    /// @param poolKeyHash The hash of the pool key for indexing.
+    /// @param params The swap parameters.
+    /// @param amount0 The amount of token0.
+    /// @param amount1 The amount of token1.
+    /// @param isCoinBuy Whether the swap is a coin buy.
+    /// @param hookData The data passed into the hook for the swap.
+    event Swapped(
+        address indexed sender,
+        address indexed swapSender,
+        bool isTrustedSwapSenderAddress,
+        PoolKey key,
+        bytes32 indexed poolKeyHash,
+        SwapParams params,
+        int128 amount0,
+        int128 amount1,
+        bool isCoinBuy,
+        bytes hookData,
+        uint160 sqrtPriceX96
+    );
+
+    /// @notice Thrown when a non-coin is used to initialize a pool with this hook.
+    /// @param coin The address of the coin.
+    error NotACoin(address coin);
+
+    /// @notice Coin version lookup cannot be the zero address.
+    error CoinVersionLookupCannotBeZeroAddress();
+
+    /// @notice Thrown when a pool is not initialized for the hook.
+    /// @param key The pool key struct to identify the pool.
+    error NoCoinForHook(PoolKey key);
+
+    /// @notice Thrown when a attempting to swap with a path that has no steps.
+    error PathMustHaveAtLeastOneStep();
+
+    /// @notice The pool coin struct. Lists all the contract-created positions for the coin.
+    struct PoolCoin {
+        /// @notice The address of the coin.
+        address coin;
+        /// @notice The positions of the pool coin.
+        LpPosition[] positions;
+    }
+
+    /// @notice The rewards accrued from the market's liquidity position
+    /// @param creatorPayoutAmountCurrency The amount of currency payed out to the creator
+    /// @param creatorPayoutAmountCoin The amount of coin payed out to the creator
+    /// @param platformReferrerAmountCurrency The amount of currency payed out to the platform referrer
+    /// @param platformReferrerAmountCoin The amount of coin payed out to the platform referrer
+    /// @param tradeReferrerAmountCurrency The amount of currency payed out to the trade referrer
+    /// @param tradeReferrerAmountCoin The amount of coin to pay to the trade referrer
+    /// @param protocolAmountCurrency The amount of currency to pay to the protocol
+    /// @param protocolAmountCoin The amount of coin to pay to the protocol
+    /// @param dopplerAmountCurrency The amount of currency to pay to doppler
+    /// @param dopplerAmountCoin The amount of coin to pay to doppler
+    struct MarketRewardsV4 {
+        uint256 creatorPayoutAmountCurrency;
+        uint256 creatorPayoutAmountCoin;
+        uint256 platformReferrerAmountCurrency;
+        uint256 platformReferrerAmountCoin;
+        uint256 tradeReferrerAmountCurrency;
+        uint256 tradeReferrerAmountCoin;
+        uint256 protocolAmountCurrency;
+        uint256 protocolAmountCoin;
+        uint256 dopplerAmountCurrency;
+        uint256 dopplerAmountCoin;
+    }
+
+    /// @notice Emitted when market rewards are distributed
+    /// @param coin The address of the coin
+    /// @param currency The address of the currency
+    /// @param payoutRecipient The address of the creator rewards payout recipient
+    /// @param platformReferrer The address of the platform referrer
+    /// @param protocolRewardRecipient The address of the protocol reward recipient
+    /// @param dopplerRecipient The address of the doppler recipient
+    /// @param tradeReferrer The address of the trade referrer
+    /// @param marketRewards The rewards accrued from the market's liquidity position
+    event CoinMarketRewardsV4(
+        address coin,
+        address currency,
+        address payoutRecipient,
+        address platformReferrer,
+        address tradeReferrer,
+        address protocolRewardRecipient,
+        address dopplerRecipient,
+        MarketRewardsV4 marketRewards
+    );
+
+    /// @notice Returns the pool coin for a given pool key hash.
+    /// @param poolKeyHash The hash of the pool key for indexing.
+    /// @return poolCoin The pool coin confirmation data.
+    function getPoolCoinByHash(bytes23 poolKeyHash) external view returns (IZoraV4CoinHook.PoolCoin memory);
+
+    /// @notice Returns the pool coin for a given pool key.
+    /// @param key The pool key.
+    /// @return poolCoin The pool coin confirmation data.
+    function getPoolCoin(PoolKey memory key) external view returns (IZoraV4CoinHook.PoolCoin memory);
+
+    /// @notice Returns whether the sender is a trusted message sender.
+    /// @param sender The address of the sender.
+    /// @return isTrusted Whether the sender is a trusted message sender.
+    function isTrustedMessageSender(address sender) external view returns (bool);
+}

package/src/libs/CoinCommon.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+library CoinCommon {
+    // Helper function to sort tokens and determine if coin is token0
+    function sortTokens(address coin, address currency) internal pure returns (bool isCoinToken0) {
+        return coin < currency;
+    }
+
+    function hashPoolKey(PoolKey memory key) internal pure returns (bytes32) {
+        return keccak256(abi.encode(key));
+    }
+}

package/src/libs/CoinConfigurationVersions.sol

@@ -1,9 +1,124 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
+import {CoinConstants} from "./CoinConstants.sol";
+
 library CoinConfigurationVersions {
     uint8 constant LEGACY_POOL_VERSION = 1;
     uint8 constant DOPPLER_UNI_V3_POOL_VERSION = 2;
+    uint8 constant DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION = 4;
+
+    function getVersion(bytes memory poolConfig) internal pure returns (uint8 version) {
+        return (version) = abi.decode(poolConfig, (uint8));
+    }
+
+    function isV3(uint8 version) internal pure returns (bool) {
+        return version == DOPPLER_UNI_V3_POOL_VERSION || version == LEGACY_POOL_VERSION;
+    }
+
+    function isV4(uint8 version) internal pure returns (bool) {
+        return version == DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION;
+    }
+
+    function decodeVersionAndCurrency(bytes memory poolConfig) internal pure returns (uint8 version, address currency) {
+        (version, currency) = abi.decode(poolConfig, (uint8, address));
+    }
+
+    function decodeDopplerUniV3(
+        bytes memory poolConfig
+    )
+        internal
+        pure
+        returns (uint8 version, address currency, int24 tickLower_, int24 tickUpper_, uint16 numDiscoveryPositions_, uint256 maxDiscoverySupplyShare_)
+    {
+        (version, currency, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_) = abi.decode(
+            poolConfig,
+            (uint8, address, int24, int24, uint16, uint256)
+        );
+    }
+
+    function encodeDopplerUniV3(
+        address currency,
+        int24 tickLower_,
+        int24 tickUpper_,
+        uint16 numDiscoveryPositions_,
+        uint256 maxDiscoverySupplyShare_
+    ) internal pure returns (bytes memory) {
+        return abi.encode(DOPPLER_UNI_V3_POOL_VERSION, currency, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
+    }
+
+    function decodeLegacy(bytes memory poolConfig) internal pure returns (uint8 version, address currency, int24 tickLower_) {
+        (version, currency, tickLower_) = abi.decode(poolConfig, (uint8, address, int24));
+    }
+
+    function decodeVanillaUniV4(bytes memory poolConfig) internal pure returns (uint8 version, address currency, int24 tickLower_) {
+        (version, currency, tickLower_) = abi.decode(poolConfig, (uint8, address, int24));
+    }
+
+    function encodeDopplerMultiCurveUniV4(
+        address currency,
+        int24[] memory tickLower_,
+        int24[] memory tickUpper_,
+        uint16[] memory numDiscoveryPositions_,
+        uint256[] memory maxDiscoverySupplyShare_
+    ) internal pure returns (bytes memory) {
+        return abi.encode(DOPPLER_MULTICURVE_UNI_V4_POOL_VERSION, currency, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_);
+    }
+
+    function decodeDopplerMultiCurveUniV4(
+        bytes memory poolConfig
+    )
+        internal
+        pure
+        returns (
+            uint8 version,
+            address currency,
+            int24[] memory tickLower_,
+            int24[] memory tickUpper_,
+            uint16[] memory numDiscoveryPositions_,
+            uint256[] memory maxDiscoverySupplyShare_
+        )
+    {
+        (version, currency, tickLower_, tickUpper_, numDiscoveryPositions_, maxDiscoverySupplyShare_) = abi.decode(
+            poolConfig,
+            (uint8, address, int24[], int24[], uint16[], uint256[])
+        );
+    }
+
+    function defaultDopplerUniV3(address currency) internal pure returns (bytes memory) {
+        return
+            encodeDopplerUniV3(
+                currency,
+                CoinConstants.DEFAULT_DISCOVERY_TICK_LOWER,
+                CoinConstants.DEFAULT_DISCOVERY_TICK_UPPER,
+                CoinConstants.DEFAULT_NUM_DISCOVERY_POSITIONS,
+                CoinConstants.DEFAULT_DISCOVERY_SUPPLY_SHARE
+            );
+    }
+
+    function defaultDopplerMultiCurveUniV4(address currency) internal pure returns (bytes memory) {
+        int24[] memory tickLower = new int24[](2);
+        int24[] memory tickUpper = new int24[](2);
+        uint16[] memory numDiscoveryPositions = new uint16[](2);
+        uint256[] memory maxDiscoverySupplyShare = new uint256[](2);
+
+        // todo: configure defaults
+        // Curve 1
+        tickLower[0] = -328_000;
+        tickUpper[0] = -300_000;
+        numDiscoveryPositions[0] = 2;
+        maxDiscoverySupplyShare[0] = 0.1e18;
+
+        // Curve 2
+        tickLower[1] = -200_000;
+        tickUpper[1] = -100_000;
+        numDiscoveryPositions[1] = 2;
+        maxDiscoverySupplyShare[1] = 0.1e18;
+
+        return encodeDopplerMultiCurveUniV4(currency, tickLower, tickUpper, numDiscoveryPositions, maxDiscoverySupplyShare);
+    }
 
-    error InvalidPoolVersion();
+    function defaultConfig(address currency) internal pure returns (bytes memory) {
+        return defaultDopplerUniV3(currency);
+    }
 }

package/src/{utils → libs}/CoinConstants.sol

@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.23;
 
-abstract contract CoinConstants {
+library CoinConstants {
     /// @notice The maximum total supply
     /// @dev Set to 1 billion coins with 18 decimals
     uint256 public constant MAX_TOTAL_SUPPLY = 1_000_000_000e18;
 
     /// @notice The number of coins allocated to the liquidity pool
     /// @dev 990 million coins
-    uint256 internal constant POOL_LAUNCH_SUPPLY = 990_000_000e18;
+    uint256 public constant POOL_LAUNCH_SUPPLY = 990_000_000e18;
 
     /// @notice The number of coins rewarded to the creator
     /// @dev 10 million coins
-    uint256 internal constant CREATOR_LAUNCH_REWARD = 10_000_000e18;
+    uint256 public constant CREATOR_LAUNCH_REWARD = 10_000_000e18;
 
     /// @notice The minimum order size allowed for trades
     /// @dev Set to 0.0000001 ETH to prevent dust transactions
@@ -40,13 +40,18 @@ abstract contract CoinConstants {
 
     /// @notice The percentage of the LP fee allocated to creators
     /// @dev 5000 basis points = 50% of the 1% LP FEE
-    uint256 internal constant CREATOR_MARKET_REWARD_BPS = 5000;
+    uint256 public constant CREATOR_MARKET_REWARD_BPS = 5000;
 
     /// @notice The percentage of the LP fee allocated to platform referrers
     /// @dev 2500 basis points = 25% of the 1% LP FEE
-    uint256 internal constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
+    uint256 public constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
 
     /// @notice The percentage of the LP fee allocated to the Doppler protocol
     /// @dev 500 basis points = 5% of the 1% LP FEE
-    uint256 internal constant DOPPLER_MARKET_REWARD_BPS = 500;
+    uint256 public constant DOPPLER_MARKET_REWARD_BPS = 500;
+
+    int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = -777000;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = 222000;
+    uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = 10; // will be 11 total with tail position
+    uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = 0.495e18; // half of the 990m total pool supply
 }

package/src/libs/CoinDopplerMultiCurve.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT
+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 {FullMath} from "../utils/uniswap/FullMath.sol";
+import {TickMath} from "../utils/uniswap/TickMath.sol";
+import {IDopplerErrors} from "../interfaces/IDopplerErrors.sol";
+import {DopplerMath} from "./DopplerMath.sol";
+
+library CoinDopplerMultiCurve {
+    error ArrayLengthMismatch();
+    error ZeroDiscoveryPositions();
+    error ZeroDiscoverySupplyShare();
+    error InvalidTickRangeMisordered(int24 tickLower, int24 tickUpper);
+    error ConfigTickLowerMustBeLessThanTickUpper();
+
+    /**
+     * @notice Configures multi-curve liquidity based on the provided parameters.
+     * @param isCoinToken0 A boolean indicating if the coin is token0 (true) or token1 (false) in the pair.
+     *                     This affects tick ordering and price calculations.
+     * @param poolConfig_ ABI encoded data containing the pool configuration parameters.
+     *                    It is expected to be encoded in the following order:
+     *                    - version (uint8): The version of the pool configuration.
+     *                                     (e.g., 2 for UniswapV3, 4 for Doppler/Uniswap V4).
+     *                    - currency (address): The address of the currency token (e.g., WETH) paired with the coin.
+     *                    - tickLower (int24[]): An array of lower tick boundaries for each liquidity curve.
+     *                    - tickUpper (int24[]): An array of upper tick boundaries for each liquidity curve.
+     *                    - numDiscoveryPositions (uint16[]): An array specifying the number of discrete liquidity
+     *                                                      positions within each curve's discovery phase.
+     *                    - maxDiscoverySupplyShare (uint256[]): An array of WAD-scaled values (1e18) representing
+     *                                                           the maximum share of the coin's total supply
+     *                                                           allocated to each curve's discovery phase.
+     * @return sqrtPriceX96 The initial square root price of the pool, scaled to X96 format.
+     * @return poolConfiguration A struct containing the configured pool parameters,
+     *                           including version, number of positions, fee, tick spacing,
+     *                           and arrays for discovery positions, tick boundaries, and supply shares.
+     */
+    function setupPool(bool isCoinToken0, bytes memory poolConfig_) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
+        (, , int24[] memory tickLower_, int24[] memory tickUpper_, uint16[] memory numDiscoveryPositions_, uint256[] memory maxDiscoverySupplyShare_) = abi
+            .decode(poolConfig_, (uint8, address, int24[], int24[], uint16[], uint256[]));
+
+        uint256 numCurves = tickLower_.length;
+        if (numCurves != tickUpper_.length || numCurves != numDiscoveryPositions_.length || numCurves != maxDiscoverySupplyShare_.length) {
+            revert ArrayLengthMismatch();
+        }
+
+        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);
+
+        // For each curve:
+        for (uint256 i; i < numCurves; i++) {
+            // Ensure a value is specified
+            require(numDiscoveryPositions_[i] > 0, ZeroDiscoveryPositions());
+            require(maxDiscoverySupplyShare_[i] > 0, ZeroDiscoverySupplyShare());
+
+            // Aggregate the total discovery positions and supply across curves
+            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);
+
+            require(currentTickLower < currentTickUpper, ConfigTickLowerMustBeLessThanTickUpper());
+
+            // Sort the tick values based on token order
+            tickLower_[i] = isCoinToken0 ? currentTickLower : -currentTickUpper;
+            tickUpper_[i] = isCoinToken0 ? currentTickUpper : -currentTickLower;
+
+            boundryTickLower = boundryTickLower < tickLower_[i] ? boundryTickLower : tickLower_[i];
+            boundryTickUpper = boundryTickUpper > tickUpper_[i] ? boundryTickUpper : tickUpper_[i];
+        }
+
+        require(boundryTickLower < boundryTickUpper, InvalidTickRangeMisordered(boundryTickLower, boundryTickUpper));
+        require(totalDiscoveryPositions > 1 && totalDiscoveryPositions <= 200, IDopplerErrors.NumDiscoveryPositionsOutOfRange());
+        require(totalDiscoverySupplyShare < MarketConstants.WAD, IDopplerErrors.MaxShareToBeSoldExceeded(totalDiscoverySupplyShare, MarketConstants.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,
+            numDiscoveryPositions: numDiscoveryPositions_,
+            tickLower: tickLower_,
+            tickUpper: tickUpper_,
+            maxDiscoverySupplyShare: maxDiscoverySupplyShare_
+        });
+    }
+
+    /// @notice Calculates the LP positions for a given multi-curve configuration
+    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
+        positions = new LpPosition[](poolConfiguration.numPositions);
+
+        uint256 discoverySupply;
+        uint256 currentPositionOffset;
+        uint256 numCurves = poolConfiguration.tickLower.length;
+
+        for (uint256 i; i < numCurves; i++) {
+            uint256 curveSupply = FullMath.mulDiv(MarketConstants.POOL_LAUNCH_SUPPLY, poolConfiguration.maxDiscoverySupplyShare[i], MarketConstants.WAD);
+
+            (positions, curveSupply) = DopplerMath.calculateLogNormalDistribution(
+                poolConfiguration.tickLower[i],
+                poolConfiguration.tickUpper[i],
+                MarketConstants.TICK_SPACING,
+                isCoinToken0,
+                curveSupply,
+                poolConfiguration.numDiscoveryPositions[i],
+                positions,
+                currentPositionOffset
+            );
+
+            discoverySupply += curveSupply;
+            currentPositionOffset += poolConfiguration.numDiscoveryPositions[i];
+        }
+
+        uint256 tailSupply = MarketConstants.POOL_LAUNCH_SUPPLY - discoverySupply;
+
+        // Calculate the tail position (the last position in the array)
+        positions[poolConfiguration.numPositions - 1] = DopplerMath.calculateLpTail(
+            poolConfiguration.tickLower[numCurves - 1],
+            poolConfiguration.tickUpper[numCurves - 1],
+            isCoinToken0,
+            tailSupply,
+            MarketConstants.TICK_SPACING
+        );
+    }
+}