@zoralabs/limit-orders 0.2.0 → 0.2.2

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/ISetLimitOrderConfig.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {LimitOrderConfig} from "../libs/SwapLimitOrders.sol";
+
+/// @title ISetLimitOrderConfig
+/// @notice Interface for setting limit order configuration
+interface ISetLimitOrderConfig {
+    /// @notice Sets the canonical limit order configuration
+    /// @param config The new limit order configuration
+    function setLimitOrderConfig(LimitOrderConfig memory config) external;
+}

package/src/router/SwapWithLimitOrders.sol

@@ -18,6 +18,7 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
 import {SwapLimitOrders, LimitOrderConfig, Orders} from "../libs/SwapLimitOrders.sol";
+import {ISetLimitOrderConfig} from "./ISetLimitOrderConfig.sol";
 import {ISwapRouter} from "@zoralabs/shared-contracts/interfaces/uniswap/ISwapRouter.sol";
 import {ISupportsLimitOrderFill} from "@zoralabs/coins/src/interfaces/ISupportsLimitOrderFill.sol";
 import {IMsgSender} from "@zoralabs/coins/src/interfaces/IMsgSender.sol";
@@ -25,8 +26,9 @@ import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 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 {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.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 +37,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 ISetLimitOrderConfig, Ownable2Step, IMsgSender {
     using SafeERC20 for IERC20;
     using BalanceDeltaLibrary for BalanceDelta;
     using CurrencyLibrary for Currency;
@@ -51,6 +53,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 +102,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
     );
 
@@ -113,9 +123,6 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
     /// @notice Error thrown when caller is not the pool manager
     error OnlyPoolManager();
 
-    /// @notice Error thrown when caller is not the authority
-    error OnlyAuthority();
-
     /// @notice Error thrown when config does not match canonical config
     error InvalidLimitOrderConfig();
 
@@ -133,7 +140,8 @@ 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_) {
+    /// @param owner_ The owner address
+    constructor(IPoolManager poolManager_, IZoraLimitOrderBook zoraLimitOrderBook_, ISwapRouter swapRouter_, address permit2_, address owner_) Ownable(owner_) {
         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
@@ -150,10 +159,9 @@ contract SwapWithLimitOrders is IMsgSender, Permit2Payments {
     }
 
     /// @notice Sets the canonical limit order configuration
-    /// @dev Only callable by zoraLimitOrderBook.authority()
+    /// @dev Only callable by the owner
     /// @param config The new limit order configuration
-    function setLimitOrderConfig(LimitOrderConfig memory config) external {
-        require(msg.sender == SimpleAccessManaged(address(zoraLimitOrderBook)).authority(), OnlyAuthority());
+    function setLimitOrderConfig(LimitOrderConfig memory config) external onlyOwner {
         SwapLimitOrders.validate(config);
         _limitOrderConfig = config;
         emit LimitOrderConfigUpdated(config.multiples, config.percentages);
@@ -218,17 +226,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 +292,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 +419,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