@zoralabs/limit-orders 0.2.0

package/src/libs/LimitOrderCreate.sol

@@ -0,0 +1,277 @@
+// 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 {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import {LimitOrderStorage} from "./LimitOrderStorage.sol";
+import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
+import {LimitOrderLiquidity} from "./LimitOrderLiquidity.sol";
+import {LimitOrderCommon} from "./LimitOrderCommon.sol";
+import {CoinCommon} from "@zoralabs/coins/src/libs/CoinCommon.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+
+library LimitOrderCreate {
+    struct CreateContext {
+        bytes32 poolKeyHash;
+        int24 currentTick;
+        address coin;
+        uint256 epoch;
+        address maker;
+        bool isCurrency0;
+    }
+
+    struct MintParams {
+        PoolKey key;
+        int24 tickLower;
+        int24 tickUpper;
+        uint128 liquidity;
+        uint128 requestedSize;
+        bytes32 orderId;
+    }
+
+    function create(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        PoolKey memory key,
+        bool isCurrency0,
+        uint256[] memory orderSizes,
+        int24[] memory orderTicks,
+        address maker
+    ) internal returns (bytes32[] memory) {
+        require(maker != address(0), IZoraLimitOrderBook.ZeroMaker());
+
+        (IZoraLimitOrderBook.CreateCallbackData memory createData, uint256 totalSize) = _prepareCreateData(key, isCurrency0, orderSizes, orderTicks, maker);
+
+        // Pull funds from specified address
+        _pullFunds(createData.key, createData.isCurrency0, totalSize, msg.sender, address(this));
+
+        // Check if we're already in an unlock callback to avoid double-unlock
+        if (TransientStateLibrary.isUnlocked(poolManager)) {
+            // Already unlocked - execute directly without calling unlock
+            return _create(state, poolManager, createData);
+        }
+
+        // Not in unlock - need to unlock
+        bytes memory result = poolManager.unlock(abi.encode(IZoraLimitOrderBook.CallbackId.CREATE, abi.encode(createData)));
+
+        return abi.decode(result, (bytes32[]));
+    }
+
+    function handleCreateCallback(LimitOrderStorage.Layout storage state, IPoolManager poolManager, bytes memory payload) internal returns (bytes memory) {
+        IZoraLimitOrderBook.CreateCallbackData memory data = abi.decode(payload, (IZoraLimitOrderBook.CreateCallbackData));
+        _validateOrderInputs(data.orderSizes, data.orderTicks, data.maker);
+
+        bytes32[] memory orderIds = _create(state, poolManager, data);
+
+        return abi.encode(orderIds);
+    }
+
+    function _validateOrderInputs(uint256[] memory orderSizes, int24[] memory orderTicks, address maker) private pure returns (uint256 total) {
+        require(maker != address(0), IZoraLimitOrderBook.ZeroMaker());
+
+        uint256 length = orderSizes.length;
+        require(length == orderTicks.length, IZoraLimitOrderBook.ArrayLengthMismatch());
+
+        for (uint256 i; i < length; ) {
+            uint256 size = orderSizes[i];
+            require(size != 0, IZoraLimitOrderBook.ZeroOrderSize());
+            total += size;
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function _pullFunds(PoolKey memory key, bool isCurrency0, uint256 total, address payer, address book) private {
+        address coin = LimitOrderCommon.getOrderCoin(key, isCurrency0);
+
+        if (coin == address(0)) {
+            require(msg.value == total, IZoraLimitOrderBook.NativeValueMismatch());
+        } else {
+            require(msg.value == 0, IZoraLimitOrderBook.NativeValueMismatch());
+
+            uint256 beforeBalance = IERC20(coin).balanceOf(book);
+
+            require(IERC20(coin).transferFrom(payer, book, total), IZoraLimitOrderBook.InsufficientTransferFunds());
+            require(IERC20(coin).balanceOf(book) == beforeBalance + total, IZoraLimitOrderBook.InsufficientTransferFunds());
+        }
+    }
+
+    function _create(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        IZoraLimitOrderBook.CreateCallbackData memory data
+    ) private returns (bytes32[] memory orderIds) {
+        PoolKey memory key = data.key;
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(key);
+
+        // If this is the first order for this pool, store the pool key
+        if (state.poolKeys[poolKeyHash].tickSpacing == 0) {
+            state.poolKeys[poolKeyHash] = key;
+        }
+
+        CreateContext memory ctx = CreateContext({
+            poolKeyHash: poolKeyHash,
+            currentTick: _getCurrentPoolTick(poolManager, key),
+            coin: LimitOrderCommon.getOrderCoin(key, data.isCurrency0),
+            epoch: state.poolEpochs[poolKeyHash],
+            maker: data.maker,
+            isCurrency0: data.isCurrency0
+        });
+
+        orderIds = new bytes32[](data.orderSizes.length);
+
+        for (uint256 i; i < data.orderSizes.length; ) {
+            orderIds[i] = _createSingleOrder(state, poolManager, key, ctx, data.orderSizes, data.orderTicks, i);
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function _createSingleOrder(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        PoolKey memory key,
+        CreateContext memory ctx,
+        uint256[] memory orderSizes,
+        int24[] memory orderTicks,
+        uint256 index
+    ) private returns (bytes32 orderId) {
+        uint256 orderSize;
+        int24 orderTick;
+
+        assembly ("memory-safe") {
+            orderSize := mload(add(add(orderSizes, 0x20), mul(index, 0x20)))
+            orderTick := mload(add(add(orderTicks, 0x20), mul(index, 0x20)))
+        }
+
+        (int24 tickLower, int24 tickUpper) = _calculateTickRange(ctx.isCurrency0, orderTick, key.tickSpacing);
+
+        uint128 liquidity = LimitOrderLiquidity.liquidityForOrder(ctx.isCurrency0, orderSize, tickLower, tickUpper);
+        require(liquidity != 0, IZoraLimitOrderBook.ZeroRealizedOrder());
+
+        orderId = _generateOrderId(ctx.poolKeyHash, ctx.coin, orderTick, ctx.maker, ++state.makerNonces[ctx.maker]);
+
+        MintParams memory mintParams = MintParams({
+            key: key,
+            tickLower: tickLower,
+            tickUpper: tickUpper,
+            liquidity: liquidity,
+            requestedSize: uint128(orderSize),
+            orderId: orderId
+        });
+
+        _mintAndRecordOrder(state, poolManager, orderTick, ctx, mintParams);
+    }
+
+    function _calculateTickRange(bool isCurrency0, int24 orderTick, int24 spacing) private pure returns (int24 tickLower, int24 tickUpper) {
+        if (isCurrency0) {
+            tickLower = orderTick;
+            tickUpper = orderTick + spacing;
+        } else {
+            tickLower = orderTick - spacing;
+            tickUpper = orderTick;
+        }
+    }
+
+    function _generateOrderId(bytes32 poolKeyHash, address coin, int24 orderTick, address maker, uint256 nonce) private pure returns (bytes32 orderId) {
+        assembly ("memory-safe") {
+            let ptr := mload(0x40)
+            mstore(ptr, poolKeyHash)
+            mstore(add(ptr, 0x20), coin)
+            mstore(add(ptr, 0x40), orderTick)
+            mstore(add(ptr, 0x60), maker)
+            mstore(add(ptr, 0x80), nonce)
+            orderId := keccak256(ptr, 0xa0)
+        }
+    }
+
+    function _mintAndRecordOrder(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        int24 orderTick,
+        CreateContext memory ctx,
+        MintParams memory mintParams
+    ) private {
+        (uint128 realized, uint128 refunded) = _mintLiquidity(poolManager, ctx.isCurrency0, mintParams);
+
+        if (refunded != 0) {
+            LimitOrderLiquidity.refundResidual(mintParams.key, ctx.isCurrency0, ctx.maker, refunded);
+        }
+
+        LimitOrderCommon.recordCreation(
+            state,
+            mintParams.key,
+            ctx.poolKeyHash,
+            mintParams.orderId,
+            ctx.maker,
+            ctx.coin,
+            ctx.isCurrency0,
+            orderTick,
+            ctx.currentTick,
+            ctx.epoch,
+            mintParams.liquidity,
+            realized,
+            mintParams.tickLower,
+            mintParams.tickUpper
+        );
+    }
+
+    function _mintLiquidity(IPoolManager poolManager, bool isCurrency0, MintParams memory params) private returns (uint128 realizedSize, uint128 refunded) {
+        (BalanceDelta delta, ) = poolManager.modifyLiquidity(
+            params.key,
+            ModifyLiquidityParams({
+                tickLower: params.tickLower,
+                tickUpper: params.tickUpper,
+                liquidityDelta: int256(uint256(params.liquidity)),
+                salt: params.orderId
+            }),
+            ""
+        );
+
+        int128 amount0 = delta.amount0();
+        int128 amount1 = delta.amount1();
+
+        if (isCurrency0) {
+            realizedSize = amount0 < 0 ? uint128(uint256(int256(-amount0))) : 0;
+        } else {
+            realizedSize = amount1 < 0 ? uint128(uint256(int256(-amount1))) : 0;
+        }
+
+        require(realizedSize != 0, IZoraLimitOrderBook.ZeroRealizedOrder());
+
+        if (realizedSize < params.requestedSize) {
+            refunded = params.requestedSize - realizedSize;
+        }
+
+        LimitOrderLiquidity.settleAfterCreate(poolManager, params.key, isCurrency0);
+    }
+
+    function _prepareCreateData(
+        PoolKey memory key,
+        bool isCurrency0,
+        uint256[] memory orderSizes,
+        int24[] memory orderTicks,
+        address maker
+    ) private pure returns (IZoraLimitOrderBook.CreateCallbackData memory data, uint256 totalSize) {
+        totalSize = _validateOrderInputs(orderSizes, orderTicks, maker);
+        data = IZoraLimitOrderBook.CreateCallbackData({key: key, isCurrency0: isCurrency0, orderSizes: orderSizes, orderTicks: orderTicks, maker: maker});
+    }
+
+    function _getCurrentPoolTick(IPoolManager poolManager, PoolKey memory key) private view returns (int24 tick) {
+        (, tick, , ) = StateLibrary.getSlot0(poolManager, PoolIdLibrary.toId(key));
+    }
+}

package/src/libs/LimitOrderFill.sol

@@ -0,0 +1,362 @@
+// 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 {TickBitmap} from "@uniswap/v4-core/src/libraries/TickBitmap.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+
+import {LimitOrderStorage} from "./LimitOrderStorage.sol";
+import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
+import {LimitOrderTypes} from "./LimitOrderTypes.sol";
+import {LimitOrderLiquidity} from "./LimitOrderLiquidity.sol";
+import {LimitOrderCommon} from "./LimitOrderCommon.sol";
+import {CoinCommon} from "@zoralabs/coins/src/libs/CoinCommon.sol";
+import {IDeployedCoinVersionLookup} from "@zoralabs/coins/src/interfaces/IDeployedCoinVersionLookup.sol";
+
+library LimitOrderFill {
+    using PoolIdLibrary for PoolKey;
+
+    int24 internal constant TICK_SENTINEL = type(int24).max;
+
+    struct Context {
+        IPoolManager poolManager;
+        IDeployedCoinVersionLookup versionLookup;
+    }
+
+    function validateTickRange(
+        LimitOrderStorage.Layout storage state,
+        Context memory ctx,
+        PoolKey calldata providedKey,
+        bool isCurrency0,
+        int24 startTick,
+        int24 endTick
+    ) internal 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(ctx.poolManager, canonicalKey, isCurrency0, startTick, endTick);
+        _validateTickRange(isCurrency0, resolvedStart, resolvedEnd);
+    }
+
+    function handleFillCallback(LimitOrderStorage.Layout storage state, Context memory ctx, bytes memory callbackData) internal {
+        IZoraLimitOrderBook.FillCallbackData memory data = abi.decode(callbackData, (IZoraLimitOrderBook.FillCallbackData));
+        executeFill(state, ctx, data);
+    }
+
+    function executeFill(LimitOrderStorage.Layout storage state, Context memory ctx, IZoraLimitOrderBook.FillCallbackData memory data) internal {
+        // Bump the pool's epoch to ensure that the execution has a clean snapshot and orders created mid-fill are wait for a future price movement before being processed
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(data.poolKey);
+        uint256 currentEpoch = ++state.poolEpochs[poolKeyHash];
+
+        PoolKey memory key = state.poolKeys[poolKeyHash];
+        if (key.tickSpacing == 0) {
+            key = data.poolKey;
+            if (key.tickSpacing == 0) revert IZoraLimitOrderBook.InvalidPoolKey();
+        }
+
+        int24 currentTick = _currentPoolTick(ctx.poolManager, key);
+
+        if (data.orderIds.length == 0) {
+            _fillAcrossRange(state, ctx, data, currentTick);
+            return;
+        }
+
+        bool isCurrency0 = data.isCurrency0;
+        mapping(int24 => LimitOrderTypes.Queue) storage tickQueues = state.tickQueues[poolKeyHash][LimitOrderCommon.getOrderCoin(key, isCurrency0)];
+        mapping(bytes32 => LimitOrderTypes.LimitOrder) storage orders = state.limitOrders;
+        address fillReferral = data.fillReferral;
+
+        uint256 length = data.orderIds.length;
+        for (uint256 i; i < length; ) {
+            bytes32 orderId = data.orderIds[i];
+            LimitOrderTypes.LimitOrder storage order = orders[orderId];
+
+            if (
+                order.status == LimitOrderTypes.OrderStatus.OPEN &&
+                order.poolKeyHash == poolKeyHash &&
+                order.isCurrency0 == isCurrency0 &&
+                order.createdEpoch < currentEpoch &&
+                _hasCrossed(order, currentTick)
+            ) {
+                int24 orderTick = LimitOrderCommon.getOrderTick(order);
+                LimitOrderTypes.Queue storage tickQueue = tickQueues[orderTick];
+
+                _fillOrder(ctx, state, key, tickQueue, order, orderId, fillReferral);
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function _fillAcrossRange(
+        LimitOrderStorage.Layout storage state,
+        Context memory ctx,
+        IZoraLimitOrderBook.FillCallbackData memory data,
+        int24 currentTick
+    ) private {
+        if (data.maxFillCount == 0) {
+            return;
+        }
+
+        bytes32 poolKeyHash = CoinCommon.hashPoolKey(data.poolKey);
+        bool zeroForOne = !data.isCurrency0;
+        address coin = Currency.unwrap(zeroForOne ? data.poolKey.currency1 : data.poolKey.currency0);
+
+        mapping(int16 => uint256) storage bitmap = state.tickBitmaps[poolKeyHash][coin];
+        mapping(int24 => LimitOrderTypes.Queue) storage tickQueues = state.tickQueues[poolKeyHash][coin];
+        mapping(bytes32 => LimitOrderTypes.LimitOrder) storage orders = state.limitOrders;
+        uint256 currentEpoch = state.poolEpochs[poolKeyHash];
+        bytes32 ordersSlot;
+        assembly ("memory-safe") {
+            ordersSlot := orders.slot
+        }
+
+        uint256 processed;
+        uint256 fillCap = data.maxFillCount;
+        bool zeroDirection = zeroForOne;
+        int24 cursor = data.startTick;
+        int24 target = data.endTick;
+        int24 tickSpacing = data.poolKey.tickSpacing;
+
+        while (processed < fillCap) {
+            if (zeroDirection ? cursor <= target : cursor >= target) break;
+
+            (int24 nextTick, bool initialized) = TickBitmap.nextInitializedTickWithinOneWord(bitmap, cursor, tickSpacing, zeroDirection);
+            bool crossesTarget = zeroDirection ? nextTick <= target : nextTick > target;
+            if (crossesTarget) break;
+
+            if (!initialized) {
+                cursor = zeroDirection ? nextTick - 1 : nextTick;
+                continue;
+            }
+
+            LimitOrderTypes.Queue storage tickQueue;
+            bytes32 head;
+            assembly ("memory-safe") {
+                mstore(0x00, nextTick)
+                mstore(0x20, tickQueues.slot)
+                let queueSlot := keccak256(0x00, 0x40)
+                tickQueue.slot := queueSlot
+                head := sload(queueSlot)
+            }
+
+            if (head == bytes32(0)) {
+                cursor = zeroDirection ? nextTick - 1 : nextTick;
+                continue;
+            }
+
+            bytes32 orderId = head;
+            while (orderId != bytes32(0) && processed < fillCap) {
+                LimitOrderTypes.LimitOrder storage order;
+                bytes32 nextOrderId;
+                assembly ("memory-safe") {
+                    mstore(0x00, orderId)
+                    mstore(0x20, ordersSlot)
+                    let orderSlot := keccak256(0x00, 0x40)
+                    order.slot := orderSlot
+                    nextOrderId := sload(orderSlot)
+                }
+
+                if (order.status != LimitOrderTypes.OrderStatus.OPEN) {
+                    orderId = nextOrderId;
+                    continue;
+                }
+                if (order.createdEpoch == currentEpoch) break;
+                if (!_hasCrossed(order, currentTick)) {
+                    orderId = nextOrderId;
+                    continue;
+                }
+
+                _fillOrder(ctx, state, data.poolKey, tickQueue, order, orderId, data.fillReferral);
+
+                unchecked {
+                    ++processed;
+                }
+
+                orderId = nextOrderId;
+            }
+
+            cursor = zeroDirection ? nextTick - 1 : nextTick;
+        }
+    }
+
+    function _fillOrder(
+        Context memory ctx,
+        LimitOrderStorage.Layout storage state,
+        PoolKey memory key,
+        LimitOrderTypes.Queue storage tickQueue,
+        LimitOrderTypes.LimitOrder storage order,
+        bytes32 orderId,
+        address fillReferral
+    ) private {
+        order.status = LimitOrderTypes.OrderStatus.FILLED;
+
+        address coin = LimitOrderCommon.getOrderCoin(key, order.isCurrency0);
+
+        (Currency coinOutCurrency, uint128 makerAmount, uint128 referralAmount) = LimitOrderLiquidity.burnAndPayout(
+            ctx.poolManager,
+            key,
+            order,
+            orderId,
+            fillReferral,
+            coin,
+            ctx.versionLookup
+        );
+
+        int24 orderTick = LimitOrderCommon.removeOrder(state, key, coin, tickQueue, order);
+
+        emit IZoraLimitOrderBook.LimitOrderFilled(
+            order.maker,
+            coin,
+            Currency.unwrap(coinOutCurrency),
+            order.orderSize,
+            makerAmount,
+            fillReferral,
+            referralAmount,
+            order.poolKeyHash,
+            orderTick,
+            orderId
+        );
+    }
+
+    /**
+     * @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.
+     *
+     * @param poolManager Pool manager used to read the live tick.
+     * @param key Pool whose tick spacing/current tick drive alignment.
+     * @param isCurrency0 True when targeting currency0 orders (prices above anchor).
+     * @param startTick User-provided start tick or sentinel.
+     * @param endTick User-provided end tick or sentinel.
+     * @return resolvedStart Concrete start tick after resolving sentinels.
+     * @return resolvedEnd Concrete end tick after resolving sentinels.
+     */
+    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);
+    }
+
+    /**
+     * @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.
+     *
+     * @param poolManager Pool manager used to read slot0.
+     * @param key Pool key describing the pair and spacing.
+     * @param spacing Tick spacing for this pool.
+     * @return anchorTick Current tick rounded down to the aligned grid.
+     * @return nextAligned Next aligned tick above the anchor (clamped to max usable).
+     * @return prevAligned Previous aligned tick below the anchor (clamped to min usable).
+     */
+    function _alignedTicks(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        int24 spacing
+    ) private view returns (int24 anchorTick, int24 nextAligned, int24 prevAligned) {
+        int24 currentTick = _currentPoolTick(poolManager, key);
+        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;
+        }
+    }
+
+    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);
+        }
+    }
+
+    function _currentPoolTick(IPoolManager poolManager, PoolKey memory key) private view returns (int24 tick) {
+        (, tick, , ) = StateLibrary.getSlot0(poolManager, key.toId());
+    }
+
+    /// @dev Returns true if the pool tick has fully crossed the order's range.
+    function _hasCrossed(LimitOrderTypes.LimitOrder storage order, int24 currentTick) private view returns (bool) {
+        return order.isCurrency0 ? currentTick >= order.tickUpper : currentTick <= order.tickLower;
+    }
+}