@zoralabs/coins 0.6.1 → 0.7.0

package/src/interfaces/IUniswapV3Pool.sol

@@ -40,4 +40,52 @@ interface IUniswapV3Pool {
     }
 
     function slot0() external view returns (Slot0 memory slot0);
+
+    /// @notice Sets the initial price for the pool
+    /// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
+    /// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
+    function initialize(uint160 sqrtPriceX96) external;
+
+    /// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
+    /// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
+    /// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
+    /// on tickLower, tickUpper, the amount of liquidity, and the current price.
+    /// @param recipient The address for which the liquidity will be created
+    /// @param tickLower The lower tick of the position in which to add liquidity
+    /// @param tickUpper The upper tick of the position in which to add liquidity
+    /// @param amount The amount of liquidity to mint
+    /// @param data Any data that should be passed through to the callback
+    /// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
+    /// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
+    function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes calldata data) external returns (uint256 amount0, uint256 amount1);
+
+    /// @notice Collects tokens owed to a position
+    /// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
+    /// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
+    /// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
+    /// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
+    /// @param recipient The address which should receive the fees collected
+    /// @param tickLower The lower tick of the position for which to collect fees
+    /// @param tickUpper The upper tick of the position for which to collect fees
+    /// @param amount0Requested How much token0 should be withdrawn from the fees owed
+    /// @param amount1Requested How much token1 should be withdrawn from the fees owed
+    /// @return amount0 The amount of fees collected in token0
+    /// @return amount1 The amount of fees collected in token1
+    function collect(
+        address recipient,
+        int24 tickLower,
+        int24 tickUpper,
+        uint128 amount0Requested,
+        uint128 amount1Requested
+    ) external returns (uint128 amount0, uint128 amount1);
+
+    /// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
+    /// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
+    /// @dev Fees must be collected separately via a call to #collect
+    /// @param tickLower The lower tick of the position for which to burn liquidity
+    /// @param tickUpper The upper tick of the position for which to burn liquidity
+    /// @param amount How much liquidity to burn
+    /// @return amount0 The amount of token0 sent to the recipient
+    /// @return amount1 The amount of token1 sent to the recipient
+    function burn(int24 tickLower, int24 tickUpper, uint128 amount) external returns (uint256 amount0, uint256 amount1);
 }

package/src/libs/CoinConfigurationVersions.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+library CoinConfigurationVersions {
+    uint8 constant LEGACY_POOL_VERSION = 1;
+    uint8 constant DOPPLER_UNI_V3_POOL_VERSION = 2;
+
+    error InvalidPoolVersion();
+}

package/src/libs/CoinDopplerUniV3.sol

@@ -0,0 +1,202 @@
+// 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";
+import {LpPosition} from "../types/LpPosition.sol";
+import {MarketConstants} from "./MarketConstants.sol";
+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";
+
+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)
+        );
+
+        require(numDiscoveryPositions_ > 1 && numDiscoveryPositions_ <= 200, IDopplerErrors.NumDiscoveryPositionsOutOfRange());
+
+        if (maxDiscoverySupplyShare_ > MarketConstants.WAD) {
+            revert IDopplerErrors.MaxShareToBeSoldExceeded(maxDiscoverySupplyShare_, MarketConstants.WAD);
+        }
+
+        int24 savedTickLower = isCoinToken0 ? tickLower_ : -tickUpper_;
+        int24 savedTickUpper = isCoinToken0 ? tickUpper_ : -tickLower_;
+
+        sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? savedTickLower : savedTickUpper);
+
+        poolConfiguration = PoolConfiguration({
+            version: CoinConfigurationVersions.DOPPLER_UNI_V3_POOL_VERSION,
+            tickLower: savedTickLower,
+            tickUpper: savedTickUpper,
+            numPositions: numDiscoveryPositions_,
+            maxDiscoverySupplyShare: maxDiscoverySupplyShare_
+        });
+    }
+
+    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/CoinLegacy.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {PoolConfiguration, ICoin} from "../interfaces/ICoin.sol";
+import {TickMath} from "../utils/uniswap/TickMath.sol";
+import {MarketConstants} from "./MarketConstants.sol";
+import {LiquidityAmounts} from "../utils/uniswap/LiquidityAmounts.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+
+library CoinLegacy {
+    function setupPool(
+        bool isCoinToken0,
+        bytes memory poolConfig_,
+        address weth
+    ) internal pure returns (uint160 sqrtPriceX96, PoolConfiguration memory poolConfiguration) {
+        (, address currency, int24 tickLower_) = abi.decode(poolConfig_, (uint8, address, int24));
+
+        // If WETH is the pool's currency, validate the lower tick
+        if ((currency == weth || currency == address(0)) && tickLower_ > MarketConstants.LP_TICK_LOWER_WETH) {
+            revert ICoin.InvalidWethLowerTick();
+        }
+
+        int24 savedTickLower = isCoinToken0 ? tickLower_ : -MarketConstants.LP_TICK_UPPER;
+        int24 savedTickUpper = isCoinToken0 ? MarketConstants.LP_TICK_UPPER : -tickLower_;
+
+        sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? savedTickLower : savedTickUpper);
+
+        poolConfiguration = PoolConfiguration({
+            version: CoinConfigurationVersions.LEGACY_POOL_VERSION,
+            tickLower: savedTickLower,
+            tickUpper: savedTickUpper,
+            numPositions: 1,
+            maxDiscoverySupplyShare: 0
+        });
+    }
+
+    function calculatePositions(bool isCoinToken0, PoolConfiguration memory poolConfiguration) internal pure returns (LpPosition[] memory positions) {
+        positions = new LpPosition[](1);
+
+        uint160 sqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? poolConfiguration.tickLower : poolConfiguration.tickUpper);
+        uint160 farSqrtPriceX96 = TickMath.getSqrtPriceAtTick(isCoinToken0 ? poolConfiguration.tickUpper : poolConfiguration.tickLower);
+        uint128 liquidity = isCoinToken0
+            ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceX96, farSqrtPriceX96, MarketConstants.POOL_LAUNCH_SUPPLY)
+            : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceX96, farSqrtPriceX96, MarketConstants.POOL_LAUNCH_SUPPLY);
+        positions[0] = LpPosition({tickLower: poolConfiguration.tickLower, tickUpper: poolConfiguration.tickUpper, liquidity: liquidity});
+    }
+}

package/src/libs/CoinSetup.sol

@@ -0,0 +1,37 @@
+// 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 {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+
+library CoinSetup {
+    error InvalidPoolVersion();
+
+    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(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();
+        }
+    }
+}

package/src/libs/MarketConstants.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+library MarketConstants {
+    /// @notice The number of coins allocated to the liquidity pool
+    /// @dev 990 million coins
+    uint256 internal constant POOL_LAUNCH_SUPPLY = 990_000_000e18;
+
+    /// @dev Constant used to increase precision during calculations
+    uint256 constant WAD = 1e18;
+
+    /// @notice The LP fee
+    /// @dev 10000 basis points = 1%
+    uint24 internal constant LP_FEE = 10000;
+
+    /// @notice The spacing for 1% pools
+    /// @dev 200 ticks
+    int24 internal constant TICK_SPACING = 200;
+
+    /// @notice The minimum lower tick for legacy single LP WETH pools
+    int24 internal constant LP_TICK_LOWER_WETH = -208200;
+
+    /// @notice The upper tick for legacy single LP WETH pools
+    int24 internal constant LP_TICK_UPPER = 887200;
+}

package/src/types/LpPosition.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+struct LpPosition {
+    int24 tickLower;
+    int24 tickUpper;
+    uint128 liquidity;
+}

package/src/types/PoolState.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @notice The state of the pool configuration, as a doppler configuration
+struct PoolState {
+    /// @notice The address of the base asset
+    address asset;
+    /// @notice The address of the currency to trade the base asset for
+    address numeraire;
+    /// @notice The lower tick of the LP range set
+    int24 tickLower;
+    /// @notice The upper tick of the LP range set
+    int24 tickUpper;
+    /// @notice The number of positions in the LP range set
+    uint16 numPositions;
+    /// @notice Whether the pool is initialized (true for this implementation)
+    bool isInitialized;
+    /// @notice Whether the pool is exited to a market (false for this implementation)
+    bool isExited;
+    /// @notice The maximum share to be sold – the size of the discovery supply
+    uint256 maxShareToBeSold;
+    /// @notice The total tokens on the bonding curve
+    uint256 totalTokensOnBondingCurve;
+}

package/src/utils/CoinConstants.sol

@@ -39,21 +39,14 @@ abstract contract CoinConstants {
     uint256 public constant TRADE_REFERRER_FEE_BPS = 1500;
 
     /// @notice The percentage of the LP fee allocated to creators
-    /// @dev 5000 basis points = 50% of LP_FEE
+    /// @dev 5000 basis points = 50% of the 1% LP FEE
     uint256 internal constant CREATOR_MARKET_REWARD_BPS = 5000;
 
     /// @notice The percentage of the LP fee allocated to platform referrers
-    /// @dev 2500 basis points = 25% of LP_FEE
+    /// @dev 2500 basis points = 25% of the 1% LP FEE
     uint256 internal constant PLATFORM_REFERRER_MARKET_REWARD_BPS = 2500;
 
-    /// @notice The LP fee
-    /// @dev 10000 basis points = 1%
-    uint24 internal constant LP_FEE = 10000;
-
-    /// @notice The LP's minimum lower tick
-    /// @dev This is only used if the currency is WETH
-    int24 internal constant LP_TICK_LOWER_WETH = -208200;
-
-    /// @notice The LP's upper tick
-    int24 internal constant LP_TICK_UPPER = 887200;
+    /// @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;
 }

package/src/utils/uniswap/BitMath.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @dev https://github.com/Uniswap/v4-core/blob/80311e34080fee64b6fc6c916e9a51a437d0e482/src/libraries/BitMath.sol
+/// @title BitMath
+/// @dev This library provides functionality for computing bit properties of an unsigned integer
+/// @author Solady (https://github.com/Vectorized/solady/blob/8200a70e8dc2a77ecb074fc2e99a2a0d36547522/src/utils/LibBit.sol)
+library BitMath {
+    /// @notice Returns the index of the most significant bit of the number,
+    ///     where the least significant bit is at index 0 and the most significant bit is at index 255
+    /// @param x the value for which to compute the most significant bit, must be greater than 0
+    /// @return r the index of the most significant bit
+    function mostSignificantBit(uint256 x) internal pure returns (uint8 r) {
+        require(x > 0);
+
+        assembly ("memory-safe") {
+            r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
+            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
+            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
+            r := or(r, shl(4, lt(0xffff, shr(r, x))))
+            r := or(r, shl(3, lt(0xff, shr(r, x))))
+            // forgefmt: disable-next-item
+            r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)), 0x0706060506020500060203020504000106050205030304010505030400000000))
+        }
+    }
+
+    /// @notice Returns the index of the least significant bit of the number,
+    ///     where the least significant bit is at index 0 and the most significant bit is at index 255
+    /// @param x the value for which to compute the least significant bit, must be greater than 0
+    /// @return r the index of the least significant bit
+    function leastSignificantBit(uint256 x) internal pure returns (uint8 r) {
+        require(x > 0);
+
+        assembly ("memory-safe") {
+            // Isolate the least significant bit.
+            x := and(x, sub(0, x))
+            // For the upper 3 bits of the result, use a De Bruijn-like lookup.
+            // Credit to adhusson: https://blog.adhusson.com/cheap-find-first-set-evm/
+            // forgefmt: disable-next-item
+            r := shl(
+                5,
+                shr(
+                    252,
+                    shl(
+                        shl(2, shr(250, mul(x, 0xb6db6db6ddddddddd34d34d349249249210842108c6318c639ce739cffffffff))),
+                        0x8040405543005266443200005020610674053026020000107506200176117077
+                    )
+                )
+            )
+            // For the lower 5 bits of the result, use a De Bruijn lookup.
+            // forgefmt: disable-next-item
+            r := or(r, byte(and(div(0xd76453e0, shr(r, x)), 0x1f), 0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))
+        }
+    }
+}

package/src/utils/uniswap/CustomRevert.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @dev https://github.com/Uniswap/v4-core/blob/80311e34080fee64b6fc6c916e9a51a437d0e482/src/libraries/CustomRevert.sol
+/// @title Library for reverting with custom errors efficiently
+/// @notice Contains functions for reverting with custom errors with different argument types efficiently
+/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with
+/// `CustomError.selector.revertWith()`
+/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately
+library CustomRevert {
+    /// @dev ERC-7751 error for wrapping bubbled up reverts
+    error WrappedError(address target, bytes4 selector, bytes reason, bytes details);
+
+    /// @dev Reverts with the selector of a custom error in the scratch space
+    function revertWith(bytes4 selector) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            revert(0, 0x04)
+        }
+    }
+
+    /// @dev Reverts with a custom error with an address argument in the scratch space
+    function revertWith(bytes4 selector, address addr) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))
+            revert(0, 0x24)
+        }
+    }
+
+    /// @dev Reverts with a custom error with an int24 argument in the scratch space
+    function revertWith(bytes4 selector, int24 value) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            mstore(0x04, signextend(2, value))
+            revert(0, 0x24)
+        }
+    }
+
+    /// @dev Reverts with a custom error with a uint160 argument in the scratch space
+    function revertWith(bytes4 selector, uint160 value) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            mstore(0x04, and(value, 0xffffffffffffffffffffffffffffffffffffffff))
+            revert(0, 0x24)
+        }
+    }
+
+    /// @dev Reverts with a custom error with two int24 arguments
+    function revertWith(bytes4 selector, int24 value1, int24 value2) internal pure {
+        assembly ("memory-safe") {
+            let fmp := mload(0x40)
+            mstore(fmp, selector)
+            mstore(add(fmp, 0x04), signextend(2, value1))
+            mstore(add(fmp, 0x24), signextend(2, value2))
+            revert(fmp, 0x44)
+        }
+    }
+
+    /// @dev Reverts with a custom error with two uint160 arguments
+    function revertWith(bytes4 selector, uint160 value1, uint160 value2) internal pure {
+        assembly ("memory-safe") {
+            let fmp := mload(0x40)
+            mstore(fmp, selector)
+            mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))
+            mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))
+            revert(fmp, 0x44)
+        }
+    }
+
+    /// @dev Reverts with a custom error with two address arguments
+    function revertWith(bytes4 selector, address value1, address value2) internal pure {
+        assembly ("memory-safe") {
+            let fmp := mload(0x40)
+            mstore(fmp, selector)
+            mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))
+            mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))
+            revert(fmp, 0x44)
+        }
+    }
+
+    /// @notice bubble up the revert message returned by a call and revert with a wrapped ERC-7751 error
+    /// @dev this method can be vulnerable to revert data bombs
+    function bubbleUpAndRevertWith(address revertingContract, bytes4 revertingFunctionSelector, bytes4 additionalContext) internal pure {
+        bytes4 wrappedErrorSelector = WrappedError.selector;
+        assembly ("memory-safe") {
+            // Ensure the size of the revert data is a multiple of 32 bytes
+            let encodedDataSize := mul(div(add(returndatasize(), 31), 32), 32)
+
+            let fmp := mload(0x40)
+
+            // Encode wrapped error selector, address, function selector, offset, additional context, size, revert reason
+            mstore(fmp, wrappedErrorSelector)
+            mstore(add(fmp, 0x04), and(revertingContract, 0xffffffffffffffffffffffffffffffffffffffff))
+            mstore(add(fmp, 0x24), and(revertingFunctionSelector, 0xffffffff00000000000000000000000000000000000000000000000000000000))
+            // offset revert reason
+            mstore(add(fmp, 0x44), 0x80)
+            // offset additional context
+            mstore(add(fmp, 0x64), add(0xa0, encodedDataSize))
+            // size revert reason
+            mstore(add(fmp, 0x84), returndatasize())
+            // revert reason
+            returndatacopy(add(fmp, 0xa4), 0, returndatasize())
+            // size additional context
+            mstore(add(fmp, add(0xa4, encodedDataSize)), 0x04)
+            // additional context
+            mstore(add(fmp, add(0xc4, encodedDataSize)), and(additionalContext, 0xffffffff00000000000000000000000000000000000000000000000000000000))
+            revert(fmp, add(0xe4, encodedDataSize))
+        }
+    }
+}

package/src/utils/uniswap/FixedPoint96.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @dev https://github.com/Uniswap/v4-core/blob/80311e34080fee64b6fc6c916e9a51a437d0e482/src/libraries/FixedPoint96.sol
+/// @title FixedPoint96
+/// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)
+/// @dev Used in SqrtPriceMath.sol
+library FixedPoint96 {
+    uint8 internal constant RESOLUTION = 96;
+    uint256 internal constant Q96 = 0x1000000000000000000000000;
+}