@zoralabs/coins 0.9.0 → 1.0.0

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/libs/CoinConstants.sol

@@ -49,4 +49,9 @@ library CoinConstants {
     /// @notice The percentage of the LP fee allocated to the Doppler protocol
     /// @dev 500 basis points = 5% of the 1% LP FEE
     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
+        );
+    }
+}

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;
-            }
-        }
-    }
 }