@zoralabs/limit-orders 0.2.0 → 0.2.1

package/src/libs/LimitOrderViews.sol

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.28;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {LiquidityAmounts} from "@zoralabs/coins/src/utils/uniswap/LiquidityAmounts.sol";
+
+import {LimitOrderStorage} from "./LimitOrderStorage.sol";
+import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
+import {CoinCommon} from "@zoralabs/coins/src/libs/CoinCommon.sol";
+
+/// @title LimitOrderViews
+/// @notice External library for view/pure functions to reduce contract size via library linking
+library LimitOrderViews {
+    using PoolIdLibrary for PoolKey;
+
+    int24 internal constant TICK_SENTINEL = type(int24).max;
+
+    /// @notice Snaps the current pool tick to the nearest aligned tick and returns its neighbors.
+    /// @dev Uniswap v4 ticks must lie on multiples of `tickSpacing`. We round the live
+    ///      tick down to the nearest aligned value (handling negatives), clamp it inside
+    ///      the pool's usable range, then compute the next/previous aligned ticks for
+    ///      callers that need to build deterministic tick windows.
+    function _alignedTicks(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        int24 spacing
+    ) private view returns (int24 anchorTick, int24 nextAligned, int24 prevAligned) {
+        (, int24 currentTick, , ) = StateLibrary.getSlot0(poolManager, key.toId());
+        int256 remainder;
+        assembly ("memory-safe") {
+            remainder := smod(currentTick, spacing)
+        }
+
+        if (remainder == 0) {
+            anchorTick = currentTick;
+        } else if (currentTick >= 0) {
+            anchorTick = int24(int256(currentTick) - remainder);
+        } else {
+            anchorTick = int24(int256(currentTick) - remainder - spacing);
+        }
+
+        int24 minUsable = TickMath.minUsableTick(spacing);
+        int24 maxUsable = TickMath.maxUsableTick(spacing);
+
+        if (anchorTick < minUsable) {
+            anchorTick = minUsable;
+        } else if (anchorTick > maxUsable) {
+            anchorTick = maxUsable;
+        }
+
+        nextAligned = anchorTick + spacing;
+        if (nextAligned > maxUsable) {
+            nextAligned = maxUsable;
+        }
+
+        prevAligned = anchorTick - spacing;
+        if (prevAligned < minUsable) {
+            prevAligned = minUsable;
+        }
+    }
+
+    /// @notice Calculate liquidity for a limit order given size and tick range.
+    /// @param isCurrency0 Whether the order is for currency0.
+    /// @param size The size of the order.
+    /// @param tickLower Lower tick of the position.
+    /// @param tickUpper Upper tick of the position.
+    /// @return The liquidity amount for the order.
+    function liquidityForOrder(bool isCurrency0, uint256 size, int24 tickLower, int24 tickUpper) external pure returns (uint128) {
+        uint160 sqrtPriceLower = TickMath.getSqrtPriceAtTick(tickLower);
+        uint160 sqrtPriceUpper = TickMath.getSqrtPriceAtTick(tickUpper);
+        return
+            isCurrency0
+                ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceLower, sqrtPriceUpper, size)
+                : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceLower, sqrtPriceUpper, size);
+    }
+
+    /// @notice Validates and resolves tick range for fill operations.
+    /// @param state The limit order storage layout.
+    /// @param poolManager The Uniswap v4 pool manager.
+    /// @param providedKey The pool key provided by the caller.
+    /// @param isCurrency0 Whether targeting currency0 orders.
+    /// @param startTick User-provided start tick or sentinel.
+    /// @param endTick User-provided end tick or sentinel.
+    /// @return canonicalKey The canonical pool key from storage or provided key.
+    /// @return resolvedStart Concrete start tick after resolving sentinels.
+    /// @return resolvedEnd Concrete end tick after resolving sentinels.
+    function validateTickRange(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        PoolKey calldata providedKey,
+        bool isCurrency0,
+        int24 startTick,
+        int24 endTick
+    ) external view returns (PoolKey memory canonicalKey, int24 resolvedStart, int24 resolvedEnd) {
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(providedKey);
+        canonicalKey = state.poolKeys[poolKeyHash];
+        if (canonicalKey.tickSpacing == 0) {
+            canonicalKey = providedKey;
+            if (canonicalKey.tickSpacing == 0) revert IZoraLimitOrderBook.InvalidPoolKey();
+        }
+
+        (resolvedStart, resolvedEnd) = _resolveTickRange(poolManager, canonicalKey, isCurrency0, startTick, endTick);
+        _validateTickRange(isCurrency0, resolvedStart, resolvedEnd);
+    }
+
+    /// @notice Derives concrete tick bounds from user input and current pool state.
+    /// @dev Callers may pass sentinel values (`-TICK_SENTINEL` / `TICK_SENTINEL`) to mean
+    ///      "start at the current tick" or "extend one spacing away". This helper translates
+    ///      those sentinels into real ticks by snapping to the pool's aligned tick grid and
+    ///      offsetting one spacing in the appropriate direction so fills never include
+    ///      orders created in the same transaction.
+    function _resolveTickRange(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        bool isCurrency0,
+        int24 startTick,
+        int24 endTick
+    ) private view returns (int24 resolvedStart, int24 resolvedEnd) {
+        int24 spacing = key.tickSpacing;
+
+        bool startSentinel = startTick == -TICK_SENTINEL;
+        bool endSentinel = endTick == TICK_SENTINEL;
+
+        (int24 anchorTick, int24 nextAligned, int24 prevAligned) = _alignedTicks(poolManager, key, spacing);
+
+        if (startSentinel) {
+            // Treat sentinel start as anchoring the window at the aligned tick.
+            resolvedStart = anchorTick;
+            resolvedEnd = endSentinel ? (isCurrency0 ? nextAligned : prevAligned) : endTick;
+            return (resolvedStart, resolvedEnd);
+        }
+
+        if (endSentinel) {
+            resolvedStart = startTick;
+            resolvedEnd = isCurrency0 ? nextAligned : anchorTick;
+            return (resolvedStart, resolvedEnd);
+        }
+
+        resolvedStart = startTick;
+        resolvedEnd = endTick;
+        return (resolvedStart, resolvedEnd);
+    }
+
+    function _validateTickRange(bool isCurrency0, int24 startTick, int24 endTick) private pure {
+        if (startTick < TickMath.MIN_TICK || startTick > TickMath.MAX_TICK) {
+            revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
+        }
+        if (endTick < TickMath.MIN_TICK || endTick > TickMath.MAX_TICK) {
+            revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
+        }
+
+        if (isCurrency0) {
+            if (startTick > endTick) revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
+        } else {
+            if (startTick < endTick) revert IZoraLimitOrderBook.InvalidFillWindow(startTick, endTick, isCurrency0);
+        }
+    }
+}

package/src/libs/LimitOrderWithdraw.sol

@@ -9,6 +9,8 @@ pragma solidity ^0.8.28;
 
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 
 import {LimitOrderStorage} from "./LimitOrderStorage.sol";
 import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
@@ -17,15 +19,16 @@ import {LimitOrderCommon} from "./LimitOrderCommon.sol";
 import {LimitOrderLiquidity} from "./LimitOrderLiquidity.sol";
 
 library LimitOrderWithdraw {
-    function handleWithdrawOrdersCallback(LimitOrderStorage.Layout storage state, IPoolManager poolManager, bytes memory payload) internal {
+    function handleWithdrawOrdersCallback(LimitOrderStorage.Layout storage state, IPoolManager poolManager, address weth, bytes memory payload) internal {
         IZoraLimitOrderBook.WithdrawOrdersCallbackData memory data = abi.decode(payload, (IZoraLimitOrderBook.WithdrawOrdersCallbackData));
 
-        withdrawOrders(state, poolManager, data.maker, data.orderIds, data.coin, data.minAmountOut, data.recipient);
+        withdrawOrders(state, poolManager, weth, data.maker, data.orderIds, data.coin, data.minAmountOut, data.recipient);
     }
 
     function withdrawOrders(
         LimitOrderStorage.Layout storage state,
         IPoolManager poolManager,
+        address weth,
         address maker,
         bytes32[] memory orderIds,
         address coin,
@@ -47,7 +50,7 @@ library LimitOrderWithdraw {
             require(order.status == LimitOrderTypes.OrderStatus.OPEN, IZoraLimitOrderBook.OrderClosed());
 
             uint128 orderSize = order.orderSize; // Cache before cancellation
-            address currentCoin = _cancelOrder(state, poolManager, maker, orderId, order, recipient);
+            address currentCoin = _cancelOrder(state, poolManager, weth, maker, orderId, order, recipient);
 
             // Validate order coin matches expected coin
             if (currentCoin != coin) {
@@ -69,6 +72,7 @@ library LimitOrderWithdraw {
     function _cancelOrder(
         LimitOrderStorage.Layout storage state,
         IPoolManager poolManager,
+        address weth,
         address maker,
         bytes32 orderId,
         LimitOrderTypes.LimitOrder storage order,
@@ -77,6 +81,11 @@ library LimitOrderWithdraw {
         PoolKey memory key = state.poolKeys[order.poolKeyHash];
         require(key.tickSpacing != 0, IZoraLimitOrderBook.InvalidOrder());
 
+        // Prevent withdrawal of fillable orders - they must be filled instead
+        (, int24 currentTick, , ) = StateLibrary.getSlot0(poolManager, PoolIdLibrary.toId(key));
+        bool fillable = order.isCurrency0 ? currentTick >= order.tickUpper : currentTick <= order.tickLower;
+        require(!fillable, IZoraLimitOrderBook.OrderFillable());
+
         int24 orderTick = LimitOrderCommon.getOrderTick(order);
         coin = LimitOrderCommon.getOrderCoin(key, order.isCurrency0);
 
@@ -93,7 +102,7 @@ library LimitOrderWithdraw {
         LimitOrderCommon.removeOrder(state, key, coin, tickQueue, order);
 
         // External call after state is updated
-        LimitOrderLiquidity.burnAndRefund(poolManager, key, tickLower, tickUpper, liquidity, orderId, recipient, isCurrency0);
+        LimitOrderLiquidity.burnAndRefund(poolManager, key, tickLower, tickUpper, liquidity, orderId, recipient, isCurrency0, weth);
 
         emit IZoraLimitOrderBook.LimitOrderUpdated(maker, coin, order.poolKeyHash, isCurrency0, orderTick, 0, orderId, true);
     }

package/src/libs/SwapLimitOrders.sol

@@ -44,9 +44,6 @@ library SwapLimitOrders {
     /// @dev sqrt(1e18) - scales sqrt calculations without precision loss
     uint256 internal constant SQRT_MULTIPLE_SCALE = 1e9;
 
-    /// @dev Minimum coins to create orders - prevents dust
-    uint256 internal constant MIN_LIMIT_ORDER_SIZE = 1e18;
-
     /// @notice Multiples and percentages arrays have different lengths
     error LengthMismatch();
 
@@ -95,7 +92,6 @@ library SwapLimitOrders {
     /// @return unallocated Amount of totalSize not allocated (dust or partial fill)
     /// @dev Orders are sized sequentially: each order takes its percentage of remaining balance.
     ///      Orders with zero size after rounding are skipped - arrays shrink to match.
-    ///      Returns empty arrays if totalSize < MIN_LIMIT_ORDER_SIZE.
     function computeOrders(
         PoolKey memory key,
         bool isCurrency0,
@@ -104,8 +100,18 @@ library SwapLimitOrders {
         uint160 sqrtPriceX96,
         LimitOrderConfig memory config
     ) internal pure returns (Orders memory o, uint128 allocated, uint128 unallocated) {
-        if (totalSize < MIN_LIMIT_ORDER_SIZE) {
-            unallocated = uint128(totalSize);
+        if (totalSize == 0) {
+            return (o, allocated, unallocated);
+        }
+
+        // Skip order creation when at tick boundaries
+        // For currency0 (buy orders): cannot place if baseTick is at maxTick
+        // For currency1 (sell orders): cannot place if baseTick is at minTick
+        int24 maxTick = TickMath.maxUsableTick(key.tickSpacing);
+        int24 alignedBaseTick = DopplerMath.alignTickToTickSpacing(isCurrency0, baseTick, key.tickSpacing);
+
+        if (isCurrency0 ? alignedBaseTick >= maxTick : alignedBaseTick <= -maxTick) {
+            unallocated = totalSize;
             return (o, allocated, unallocated);
         }
 
@@ -185,7 +191,8 @@ library SwapLimitOrders {
             aligned = minTick;
         }
 
-        int24 minAway = baseTick + (isCurrency0 ? key.tickSpacing : -key.tickSpacing);
+        int24 alignedBaseTick = DopplerMath.alignTickToTickSpacing(isCurrency0, baseTick, key.tickSpacing);
+        int24 minAway = alignedBaseTick + (isCurrency0 ? key.tickSpacing : -key.tickSpacing);
         if (isCurrency0) {
             if (aligned < minAway) aligned = minAway;
         } else {

package/src/router/SwapWithLimitOrders.sol

@@ -26,7 +26,7 @@ import {TransientSlot} from "@openzeppelin/contracts/utils/TransientSlot.sol";
 import {Path} from "@zoralabs/shared-contracts/libs/UniswapV3/Path.sol";
 import {V3ToV4SwapLib} from "@zoralabs/coins/src/libs/V3ToV4SwapLib.sol";
 import {SimpleAccessManaged} from "../access/SimpleAccessManaged.sol";
-import {Permit2Payments} from "../libs/Permit2Payments.sol";
+import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol";
 
 /// @title SwapWithLimitOrders
 /// @notice Standalone router contract that executes swaps with automatic limit order placement and filling.
@@ -35,7 +35,7 @@ import {Permit2Payments} from "../libs/Permit2Payments.sol";
 ///      Users call swapWithLimitOrders() directly, which triggers the unlock callback flow.
 ///      Uses Permit2 for token approvals, matching the universal-router pattern.
 /// @author oveddan
-contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
+contract SwapWithLimitOrders is IMsgSender {
     using SafeERC20 for IERC20;
     using BalanceDeltaLibrary for BalanceDelta;
     using CurrencyLibrary for Currency;
@@ -51,6 +51,9 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
     /// @notice The Uniswap V3 swap router
     ISwapRouter public immutable swapRouter;
 
+    /// @notice The Permit2 contract (immutable, same address on all chains)
+    IAllowanceTransfer internal immutable PERMIT2;
+
     /// @notice Canonical limit order configuration
     LimitOrderConfig private _limitOrderConfig;
 
@@ -97,13 +100,18 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
     /// @notice Emitted when a swap with limit order placement is executed
     /// @param orders Array of created orders with their configuration. Only includes orders
     ///               that were actually created (skipped rungs due to rounding are omitted).
+    /// @param amount0 The amount of currency0 swapped (negative = paid, positive = received)
+    /// @param amount1 The amount of currency1 swapped (negative = paid, positive = received)
+    /// @param sqrtPriceX96 The sqrt price after the swap, used for USD price computation
     event SwapWithLimitOrdersExecuted(
         address indexed sender,
         address indexed recipient,
         PoolKey poolKey,
-        BalanceDelta delta,
         int24 tickBeforeSwap,
         int24 tickAfterSwap,
+        int128 amount0,
+        int128 amount1,
+        uint160 sqrtPriceX96,
         CreatedOrder[] orders
     );
 
@@ -133,7 +141,7 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
     /// @param zoraLimitOrderBook_ The limit order book contract
     /// @param swapRouter_ The Uniswap V3 swap router
     /// @param permit2_ The Permit2 contract address (0x000000000022D473030F116dDEE9F6B43aC78BA3)
-    constructor(IPoolManager poolManager_, IZoraLimitOrderBook zoraLimitOrderBook_, ISwapRouter swapRouter_, address permit2_) Permit2Payments(permit2_) {
+    constructor(IPoolManager poolManager_, IZoraLimitOrderBook zoraLimitOrderBook_, ISwapRouter swapRouter_, address permit2_) {
         require(address(poolManager_) != address(0), "PoolManager cannot be zero");
         require(address(zoraLimitOrderBook_) != address(0), "ZoraLimitOrderBook cannot be zero");
         require(address(swapRouter_) != address(0), "SwapRouter cannot be zero");
@@ -141,6 +149,7 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
         poolManager = poolManager_;
         zoraLimitOrderBook = zoraLimitOrderBook_;
         swapRouter = swapRouter_;
+        PERMIT2 = IAllowanceTransfer(permit2_);
     }
 
     /// @inheritdoc IMsgSender
@@ -218,17 +227,30 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
         // Execute V4 swaps + create orders via unlock callback
         bytes memory result = poolManager.unlock(abi.encode(callbackData));
 
-        (CreatedOrder[] memory orders, bool isCoinCurrency0, int24 tickAfterSwap) = abi.decode(result, (CreatedOrder[], bool, int24));
+        (CreatedOrder[] memory orders, bool isCoinCurrency0, int24 tickAfterSwap, uint160 sqrtPriceX96, BalanceDelta targetPoolDelta) = abi.decode(
+            result,
+            (CreatedOrder[], bool, int24, uint160, BalanceDelta)
+        );
 
         // Check if hook supports limit order filling using ERC165
         bool hookSupportsFill = IERC165(address(targetPool.hooks)).supportsInterface(type(ISupportsLimitOrderFill).interfaceId);
 
         // Router-based filling for legacy hooks
-        if (!hookSupportsFill && orders.length > 0 && tickBeforeSwap != tickAfterSwap) {
-            _fillOrders(targetPool, !isCoinCurrency0, tickBeforeSwap, tickAfterSwap);
+        if (!hookSupportsFill && tickBeforeSwap != tickAfterSwap) {
+            _fillOrders(targetPool, isCoinCurrency0, tickBeforeSwap, tickAfterSwap);
         }
 
-        emit SwapWithLimitOrdersExecuted(msg.sender, params.recipient, targetPool, BalanceDelta.wrap(0), tickBeforeSwap, tickAfterSwap, orders);
+        emit SwapWithLimitOrdersExecuted(
+            msg.sender,
+            params.recipient,
+            targetPool,
+            tickBeforeSwap,
+            tickAfterSwap,
+            targetPoolDelta.amount0(),
+            targetPoolDelta.amount1(),
+            sqrtPriceX96,
+            orders
+        );
 
         // Clear maker from transient storage
         TransientSlot.tstore(slot, address(0));
@@ -271,7 +293,7 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
         // Settle currencies with pool manager
         _settleCurrencies(callbackData.currencyReceived, callbackData.currencyAmount, coinAddress, unallocated, callbackData.recipient);
 
-        return abi.encode(createdOrders, isCoinCurrency0, currentTick);
+        return abi.encode(createdOrders, isCoinCurrency0, currentTick, sqrtPriceX96, swapResult.targetPoolDelta);
     }
 
     /// @notice Executes V4 multi-hop swaps and validates output
@@ -398,33 +420,25 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
 
             poolManager.settle();
         } else {
+            // sync before settle for native ETH
+            poolManager.sync(currency);
             poolManager.settle{value: amount}();
         }
     }
 
     /// @notice Fills limit orders within the tick range crossed by the swap
     /// @param poolKey The pool key
-    /// @param isCurrency0 Whether to fill currency0 orders
     /// @param tickBeforeSwap The tick before the swap
     /// @param tickAfterSwap The tick after the swap
-    function _fillOrders(PoolKey memory poolKey, bool isCurrency0, int24 tickBeforeSwap, int24 tickAfterSwap) internal {
-        // Ensure ticks are in the correct order for fill validation
-        // For currency0 orders: startTick <= endTick (ascending)
-        // For currency1 orders: startTick >= endTick (descending)
-        int24 startTick;
-        int24 endTick;
-        if (isCurrency0) {
-            // Currency0 orders need ascending tick range
-            startTick = tickBeforeSwap < tickAfterSwap ? tickBeforeSwap : tickAfterSwap;
-            endTick = tickBeforeSwap < tickAfterSwap ? tickAfterSwap : tickBeforeSwap;
-        } else {
-            // Currency1 orders need descending tick range
-            startTick = tickBeforeSwap > tickAfterSwap ? tickBeforeSwap : tickAfterSwap;
-            endTick = tickBeforeSwap > tickAfterSwap ? tickAfterSwap : tickBeforeSwap;
+    function _fillOrders(PoolKey memory poolKey, bool, int24 tickBeforeSwap, int24 tickAfterSwap) internal {
+        if (tickAfterSwap == tickBeforeSwap) {
+            return;
         }
 
-        // Call fill in locked mode - will trigger unlock/callback flow in ZoraLimitOrderBook
-        zoraLimitOrderBook.fill(poolKey, isCurrency0, startTick, endTick, 0, address(0));
+        // Derive fill direction from tick movement
+        bool isCurrency0 = tickAfterSwap > tickBeforeSwap;
+
+        zoraLimitOrderBook.fill(poolKey, isCurrency0, tickBeforeSwap, tickAfterSwap, 0, address(0));
     }
 
     /// @notice Validates that the provided config matches the canonical config

package/test/LimitOrderBitmap.t.sol

@@ -30,7 +30,8 @@ contract LimitOrderBitmapTest is BaseTest {
 
         // Verify all ticks are initialized in bitmap
         for (uint256 i; i < orderTicks.length; ++i) {
-            assertTrue(_isTickInitialized(poolKeyHash, orderCoin, orderTicks[i], key.tickSpacing), "tick should be initialized");
+            int24 fillableTick = _fillableTick(isCurrency0, orderTicks[i], key.tickSpacing);
+            assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should be initialized");
         }
     }
 
@@ -52,7 +53,8 @@ contract LimitOrderBitmapTest is BaseTest {
         bytes32 poolKeyHash = created[0].poolKeyHash;
 
         // Verify tick is initialized
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, orderTicks[0], key.tickSpacing), "tick should be initialized after create");
+        int24 fillableTick = _fillableTick(isCurrency0, orderTicks[0], key.tickSpacing);
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should be initialized after create");
 
         // Withdraw order
         bytes32[] memory orderIds = new bytes32[](1);
@@ -61,7 +63,7 @@ contract LimitOrderBitmapTest is BaseTest {
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
         // Verify tick is cleared in bitmap
-        assertFalse(_isTickInitialized(poolKeyHash, orderCoin, orderTicks[0], key.tickSpacing), "tick should be cleared after withdraw");
+        assertFalse(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should be cleared after withdraw");
     }
 
     function test_bitmap_RemainsSetWithPartialOrders() public {
@@ -95,7 +97,8 @@ contract LimitOrderBitmapTest is BaseTest {
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
         // Bitmap should still be set because second order remains
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, tick, key.tickSpacing), "tick should remain initialized with remaining order");
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should remain initialized with remaining order");
     }
 
     function test_bitmap_wordBoundaries() public {
@@ -129,7 +132,8 @@ contract LimitOrderBitmapTest is BaseTest {
 
         // Verify all boundary ticks are initialized
         for (uint256 i = 0; i < boundaryTicks.length; i++) {
-            assertTrue(_isTickInitialized(poolKeyHash, orderCoin, boundaryTicks[i], spacing), "boundary tick should be initialized");
+            int24 fillableTick = _fillableTick(isCurrency0, boundaryTicks[i], spacing);
+            assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, spacing), "boundary tick should be initialized");
         }
     }
 
@@ -171,8 +175,10 @@ contract LimitOrderBitmapTest is BaseTest {
         bytes32 poolKeyHash = created[0].poolKeyHash;
 
         // Verify extreme ticks are initialized
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, extremeTicks[0], spacing), "far tick 1 should be initialized");
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, extremeTicks[1], spacing), "far tick 2 should be initialized");
+        int24 fillableTick0 = _fillableTick(isCurrency0, extremeTicks[0], spacing);
+        int24 fillableTick1 = _fillableTick(isCurrency0, extremeTicks[1], spacing);
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick0, spacing), "far tick 1 should be initialized");
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick1, spacing), "far tick 2 should be initialized");
     }
 
     function _fundAndApprove(address user, address token, uint256 amount) internal {

package/test/LimitOrderFill.t.sol

@@ -814,6 +814,49 @@ contract LimitOrderFillTest is BaseTest {
         assertEq(fills.length, 2, "should fill default max count of 2 orders");
     }
 
+    /// @notice Tests fill() caps maxFillCount to configured default
+    function test_fill_maxFillCountExceedsDefault_isCapped() public {
+        PoolKey memory key = creatorCoin.getPoolKey();
+        bool isCurrency0 = Currency.unwrap(key.currency0) == address(creatorCoin);
+        address orderCoin = _orderCoin(key, isCurrency0);
+
+        // Set max fill count to 2
+        vm.prank(users.factoryOwner);
+        limitOrderBook.setMaxFillCount(2);
+
+        // Create 5 fillable orders
+        (uint256[] memory orderSizes, int24[] memory orderTicks) = _buildDeterministicOrders(key, isCurrency0, 5, 20e18);
+        uint256 totalSize;
+        for (uint256 i; i < orderSizes.length; ++i) {
+            totalSize += orderSizes[i];
+        }
+
+        if (orderCoin == address(0)) {
+            vm.deal(users.seller, totalSize);
+        } else {
+            deal(orderCoin, users.seller, totalSize);
+            vm.startPrank(users.seller);
+            IERC20(orderCoin).approve(address(limitOrderBook), totalSize);
+            vm.stopPrank();
+        }
+
+        vm.recordLogs();
+        vm.prank(users.seller);
+        limitOrderBook.create{value: orderCoin == address(0) ? totalSize : 0}(key, isCurrency0, orderSizes, orderTicks, users.seller);
+        CreatedOrderLog[] memory created = _decodeCreatedLogs(vm.getRecordedLogs());
+
+        _movePriceBeyondTicksWithAutoFillDisabled(created);
+        (int24 startTick, int24 endTick) = _tickWindow(created, key);
+
+        // Call fill with maxFillCount = 100 (way above default of 2)
+        vm.recordLogs();
+        limitOrderBook.fill(key, isCurrency0, startTick, endTick, 100, address(0));
+        FilledOrderLog[] memory fills = _decodeFilledLogs(vm.getRecordedLogs());
+
+        // Should cap to 2 orders (the configured max)
+        assertEq(fills.length, 2, "should cap to configured max of 2 orders");
+    }
+
     /// @notice Tests batch fill with empty orderIds array (line 134)
     /// @dev This tests the branch: if (batch.orderIds.length != 0)
     function test_batchFill_emptyOrderIds_skips() public {

package/test/LimitOrderLibraries.t.sol

@@ -67,7 +67,8 @@ contract LimitOrderLibrariesTest is BaseTest {
         assertEq(created.length, 3, "should create three orders");
 
         // Verify tick queue linked list structure
-        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, tick);
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, fillableTick);
         assertEq(tickQueue.length, 3, "queue length should be 3");
         assertEq(tickQueue.head, created[0].orderId, "head should be first order");
         assertEq(tickQueue.tail, created[2].orderId, "tail should be last order");
@@ -108,7 +109,8 @@ contract LimitOrderLibrariesTest is BaseTest {
         vm.prank(users.seller);
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
-        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, tick);
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, fillableTick);
         assertEq(tickQueue.length, 2, "queue length should be 2");
         assertEq(tickQueue.head, created[1].orderId, "head should be second order");
         assertEq(tickQueue.tail, created[2].orderId, "tail unchanged");
@@ -149,7 +151,8 @@ contract LimitOrderLibrariesTest is BaseTest {
         vm.prank(users.seller);
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
-        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, tick);
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, fillableTick);
         assertEq(tickQueue.length, 2, "queue length should be 2");
         assertEq(tickQueue.head, created[0].orderId, "head unchanged");
         assertEq(tickQueue.tail, created[1].orderId, "tail should be second order");
@@ -190,7 +193,8 @@ contract LimitOrderLibrariesTest is BaseTest {
         vm.prank(users.seller);
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
-        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, tick);
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        QueueSnapshot memory tickQueue = _tickQueueSnapshot(created[0].poolKeyHash, orderCoin, fillableTick);
         assertEq(tickQueue.length, 2, "queue length should be 2");
         assertEq(tickQueue.head, created[0].orderId, "head unchanged");
         assertEq(tickQueue.tail, created[2].orderId, "tail unchanged");
@@ -237,7 +241,8 @@ contract LimitOrderLibrariesTest is BaseTest {
 
         // Verify bitmap is set
         bytes32 poolKeyHash = keccak256(abi.encode(key));
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, orderTicks[0], key.tickSpacing), "tick should be initialized");
+        int24 fillableTick = _fillableTick(isCurrency0, orderTicks[0], key.tickSpacing);
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should be initialized");
     }
 
     function test_bitmapSetIfFirstWhenNonEmpty() public {
@@ -262,9 +267,10 @@ contract LimitOrderLibrariesTest is BaseTest {
 
         // Verify bitmap is still set (second enqueue didn't break it)
         bytes32 poolKeyHash = keccak256(abi.encode(key));
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, tick, key.tickSpacing), "tick should be initialized");
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should be initialized");
 
-        QueueSnapshot memory tickQueue = _tickQueueSnapshot(poolKeyHash, orderCoin, tick);
+        QueueSnapshot memory tickQueue = _tickQueueSnapshot(poolKeyHash, orderCoin, fillableTick);
         assertEq(tickQueue.length, 2, "should have 2 orders at same tick");
     }
 
@@ -290,7 +296,8 @@ contract LimitOrderLibrariesTest is BaseTest {
         vm.prank(users.seller);
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
-        assertFalse(_isTickInitialized(poolKeyHash, orderCoin, orderTicks[0], key.tickSpacing), "tick should be cleared");
+        int24 fillableTick = _fillableTick(isCurrency0, orderTicks[0], key.tickSpacing);
+        assertFalse(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should be cleared");
     }
 
     function test_bitmapClearIfEmptyWhenStillHasOrders() public {
@@ -323,9 +330,10 @@ contract LimitOrderLibrariesTest is BaseTest {
         vm.prank(users.seller);
         limitOrderBook.withdraw(orderIds, orderCoin, 0, users.seller);
 
-        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, tick, key.tickSpacing), "tick should still be initialized");
+        int24 fillableTick = _fillableTick(isCurrency0, tick, key.tickSpacing);
+        assertTrue(_isTickInitialized(poolKeyHash, orderCoin, fillableTick, key.tickSpacing), "tick should still be initialized");
 
-        QueueSnapshot memory tickQueue = _tickQueueSnapshot(poolKeyHash, orderCoin, tick);
+        QueueSnapshot memory tickQueue = _tickQueueSnapshot(poolKeyHash, orderCoin, fillableTick);
         assertEq(tickQueue.length, 1, "should have 1 order remaining");
     }