@zoralabs/limit-orders 0.2.1 → 0.2.4

package/src/ZoraLimitOrderBook.sol

@@ -10,7 +10,6 @@ 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 {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
-import {SimpleAccessManaged} from "./access/SimpleAccessManaged.sol";
 
 import {IDeployedCoinVersionLookup} from "@zoralabs/coins/src/interfaces/IDeployedCoinVersionLookup.sol";
 import {IZoraHookRegistry} from "@zoralabs/coins/src/interfaces/IZoraHookRegistry.sol";
@@ -21,50 +20,35 @@ import {LimitOrderFill} from "./libs/LimitOrderFill.sol";
 import {LimitOrderWithdraw} from "./libs/LimitOrderWithdraw.sol";
 import {LimitOrderViews} from "./libs/LimitOrderViews.sol";
 import {LimitOrderTypes} from "./libs/LimitOrderTypes.sol";
+import {PermittedCallers} from "./access/PermittedCallers.sol";
 
-contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
+contract ZoraLimitOrderBook is IZoraLimitOrderBook, PermittedCallers {
     IPoolManager public immutable poolManager;
     IDeployedCoinVersionLookup public immutable zoraCoinVersionLookup;
     IZoraHookRegistry public immutable zoraHookRegistry;
     address public immutable weth;
 
-    constructor(
-        address poolManager_,
-        address zoraCoinVersionLookup_,
-        address zoraHookRegistry_,
-        address authority_,
-        address weth_
-    ) SimpleAccessManaged(authority_) {
+    constructor(address poolManager_, address zoraCoinVersionLookup_, address zoraHookRegistry_, address owner_, address weth_) PermittedCallers(owner_) {
+        require(poolManager_ != address(0), AddressZero());
+        require(zoraCoinVersionLookup_ != address(0), AddressZero());
+        require(zoraHookRegistry_ != address(0), AddressZero());
+        require(weth_ != address(0), AddressZero());
+
         poolManager = IPoolManager(poolManager_);
         zoraCoinVersionLookup = IDeployedCoinVersionLookup(zoraCoinVersionLookup_);
         zoraHookRegistry = IZoraHookRegistry(zoraHookRegistry_);
-        if (weth_ == address(0)) {
-            revert AddressZero();
-        }
         weth = weth_;
     }
 
-    function tickQueueBalance(bytes32 poolKeyHash, address coin, int24 tick) internal view returns (uint256) {
-        return LimitOrderStorage.layout().tickQueues[poolKeyHash][coin][tick].balance;
-    }
-
     /// @inheritdoc IZoraLimitOrderBook
     function balanceOf(address maker, address coin) external view override returns (uint256) {
         return LimitOrderStorage.layout().makerBalances[maker][coin];
     }
 
-    function getOrder(bytes32 id) internal view returns (LimitOrderTypes.LimitOrder memory) {
-        return LimitOrderStorage.layout().limitOrders[id];
-    }
-
     function getTickQueue(bytes32 poolKeyHash, address coin, int24 tick) internal view returns (LimitOrderTypes.Queue memory) {
         return LimitOrderStorage.layout().tickQueues[poolKeyHash][coin][tick];
     }
 
-    function getPoolKey(bytes32 poolKeyHash) internal view returns (PoolKey memory) {
-        return LimitOrderStorage.layout().poolKeys[poolKeyHash];
-    }
-
     function getPoolEpoch(bytes32 poolKeyHash) internal view returns (uint256) {
         return LimitOrderStorage.layout().poolEpochs[poolKeyHash];
     }
@@ -73,10 +57,6 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         return LimitOrderStorage.layout().makerNonces[maker];
     }
 
-    function getOrderId(bytes32 poolKeyHash, address coin, int24 tick, address maker, uint256 nonce) internal pure returns (bytes32) {
-        return keccak256(abi.encode(poolKeyHash, coin, tick, maker, nonce));
-    }
-
     /// @inheritdoc IZoraLimitOrderBook
     function create(
         PoolKey memory key,
@@ -84,8 +64,7 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         uint256[] memory orderSizes,
         int24[] memory orderTicks,
         address maker
-    ) external payable override returns (bytes32[] memory) {
-        _checkCanCall(this.create.selector);
+    ) external payable override onlyPermitted returns (bytes32[] memory) {
         return LimitOrderCreate.create(LimitOrderStorage.layout(), poolManager, key, isCurrency0, orderSizes, orderTicks, maker);
     }
 
@@ -152,8 +131,10 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
 
     /// @inheritdoc IZoraLimitOrderBook
     function withdraw(bytes32[] calldata orderIds, address coin, uint256 minAmountOut, address recipient) external override {
-        bytes32[] memory orderIdsCopy = orderIds;
-        _unlock(CallbackId.WITHDRAW_ORDERS, _encodeWithdrawOrders(msg.sender, orderIdsCopy, coin, minAmountOut, recipient));
+        _unlock(
+            CallbackId.WITHDRAW_ORDERS,
+            abi.encode(WithdrawOrdersCallbackData({maker: msg.sender, orderIds: orderIds, coin: coin, minAmountOut: minAmountOut, recipient: recipient}))
+        );
     }
 
     /// @notice Processes pool-manager unlock callbacks and routes them to the correct handler.
@@ -184,9 +165,7 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         return LimitOrderStorage.layout().maxFillCount;
     }
 
-    function setMaxFillCount(uint256 maxFillCount) external {
-        _checkCanCall(this.setMaxFillCount.selector);
-
+    function setMaxFillCount(uint256 maxFillCount) external onlyOwner {
         LimitOrderStorage.layout().maxFillCount = maxFillCount;
     }
 
@@ -218,16 +197,6 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         data.orderIds = orderIds;
     }
 
-    function _encodeWithdrawOrders(
-        address maker,
-        bytes32[] memory orderIds,
-        address coin,
-        uint256 minAmountOut,
-        address recipient
-    ) private pure returns (bytes memory) {
-        return abi.encode(WithdrawOrdersCallbackData({maker: maker, orderIds: orderIds, coin: coin, minAmountOut: minAmountOut, recipient: recipient}));
-    }
-
     function _unlock(CallbackId callbackId, bytes memory payload) private {
         poolManager.unlock(abi.encode(callbackId, payload));
     }

package/src/access/PermittedCallers.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+
+abstract contract PermittedCallers is Ownable2Step {
+    address private constant PUBLIC_ACCESS = address(0);
+
+    mapping(address caller => bool permitted) private _permittedCallers;
+
+    event PermittedCallerUpdated(address indexed caller, bool permitted);
+
+    error CallerNotPermitted();
+    error PermittedCallersLengthMismatch();
+
+    constructor(address owner_) Ownable(owner_) {
+        _permittedCallers[PUBLIC_ACCESS] = true;
+    }
+
+    modifier onlyPermitted() {
+        _onlyPermitted();
+        _;
+    }
+
+    function _onlyPermitted() internal view {
+        require(_isPermitted(msg.sender), CallerNotPermitted());
+    }
+
+    function isPermittedCaller(address caller) public view returns (bool) {
+        return _isPermitted(caller);
+    }
+
+    function setPermittedCallers(address[] calldata callers, bool[] calldata permitted) external onlyOwner {
+        require(callers.length == permitted.length, PermittedCallersLengthMismatch());
+        for (uint256 i = 0; i < callers.length; i++) {
+            _permittedCallers[callers[i]] = permitted[i];
+            emit PermittedCallerUpdated(callers[i], permitted[i]);
+        }
+    }
+
+    function _isPermitted(address caller) internal view returns (bool) {
+        return _permittedCallers[PUBLIC_ACCESS] || _permittedCallers[caller];
+    }
+}

package/src/libs/LimitOrderBitmap.sol

@@ -8,7 +8,6 @@
 pragma solidity ^0.8.23;
 
 import {TickBitmap} from "@uniswap/v4-core/src/libraries/TickBitmap.sol";
-import {LimitOrderTypes} from "./LimitOrderTypes.sol";
 
 library LimitOrderBitmap {
     function setIfFirst(mapping(int16 => uint256) storage bm, int24 tick, int24 spacing, uint256 sizeBefore) internal {

package/src/libs/LimitOrderCommon.sol

@@ -9,6 +9,9 @@ pragma solidity ^0.8.28;
 
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
 
 import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
 import {LimitOrderStorage} from "./LimitOrderStorage.sol";
@@ -18,6 +21,8 @@ import {LimitOrderBitmap} from "./LimitOrderBitmap.sol";
 import {LimitOrderCreate} from "./LimitOrderCreate.sol";
 
 library LimitOrderCommon {
+    using PoolIdLibrary for PoolKey;
+
     /// @dev Currency0 orders are executed when the price rises to the upper tick.
     ///      Currency1 orders are executed when the price falls to the lower tick.
     function getOrderTick(LimitOrderTypes.LimitOrder storage order) internal view returns (int24) {
@@ -28,6 +33,15 @@ library LimitOrderCommon {
         return Currency.unwrap(isCurrency0 ? key.currency0 : key.currency1);
     }
 
+    /// @dev Returns true if the pool tick has fully crossed the order's range.
+    function hasCrossed(LimitOrderTypes.LimitOrder storage order, int24 currentTick) internal view returns (bool) {
+        return order.isCurrency0 ? currentTick >= order.tickUpper : currentTick < order.tickLower;
+    }
+
+    function currentPoolTick(IPoolManager poolManager, PoolKey memory key) internal view returns (int24 tick) {
+        (, tick, , ) = StateLibrary.getSlot0(poolManager, key.toId());
+    }
+
     function recordCreation(
         LimitOrderStorage.Layout storage state,
         LimitOrderCreate.CreateContext memory ctx,

package/src/libs/LimitOrderCreate.sol

@@ -223,6 +223,8 @@ library LimitOrderCreate {
             ModifyLiquidityParams({
                 tickLower: params.tickLower,
                 tickUpper: params.tickUpper,
+                // This is safe because liquidity is always positive
+                //forge-lint: disable-next-line(unsafe-typecast)
                 liquidityDelta: int256(uint256(params.liquidity)),
                 salt: params.orderId
             }),
@@ -233,8 +235,12 @@ library LimitOrderCreate {
         int128 amount1 = delta.amount1();
 
         if (isCurrency0) {
+            // This is safe because amount0 is always negative
+            //forge-lint: disable-next-line(unsafe-typecast)
             realizedSize = amount0 < 0 ? uint128(uint256(int256(-amount0))) : 0;
         } else {
+            // This is safe because amount1 is always negative
+            //forge-lint: disable-next-line(unsafe-typecast)
             realizedSize = amount1 < 0 ? uint128(uint256(int256(-amount1))) : 0;
         }
 

package/src/libs/LimitOrderFill.sol

@@ -10,8 +10,6 @@ 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 {PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
 import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
 
 import {LimitOrderStorage} from "./LimitOrderStorage.sol";
@@ -19,13 +17,10 @@ import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
 import {LimitOrderTypes} from "./LimitOrderTypes.sol";
 import {LimitOrderLiquidity} from "./LimitOrderLiquidity.sol";
 import {LimitOrderCommon} from "./LimitOrderCommon.sol";
-import {LimitOrderViews} from "./LimitOrderViews.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;
-
     struct Context {
         IPoolManager poolManager;
         IDeployedCoinVersionLookup versionLookup;
@@ -67,12 +62,9 @@ library LimitOrderFill {
                 order.status == LimitOrderTypes.OrderStatus.OPEN &&
                 order.poolKeyHash == poolKeyHash &&
                 order.isCurrency0 == isCurrency0 &&
-                order.createdEpoch < currentEpoch
+                order.createdEpoch < currentEpoch &&
+                LimitOrderCommon.hasCrossed(order, LimitOrderCommon.currentPoolTick(ctx.poolManager, key))
             ) {
-                if (!_hasCrossed(order, _currentPoolTick(ctx.poolManager, key))) {
-                    continue;
-                }
-
                 int24 orderTick = LimitOrderCommon.getOrderTick(order);
                 LimitOrderTypes.Queue storage tickQueue = tickQueues[orderTick];
 
@@ -160,7 +152,7 @@ library LimitOrderFill {
                 if (order.createdEpoch == currentEpoch) {
                     break;
                 }
-                if (!_hasCrossed(order, _currentPoolTick(ctx.poolManager, data.poolKey))) {
+                if (!LimitOrderCommon.hasCrossed(order, LimitOrderCommon.currentPoolTick(ctx.poolManager, data.poolKey))) {
                     return;
                 }
 
@@ -221,13 +213,4 @@ library LimitOrderFill {
             orderId
         );
     }
-
-    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;
-    }
 }

package/src/libs/LimitOrderLiquidity.sol

@@ -45,6 +45,21 @@ library LimitOrderLiquidity {
         settleDeltas(poolManager, key, delta0, delta1, payout0, payout1);
     }
 
+    /// @notice Burns a filled limit order and pays out proceeds to maker and fee recipient
+    /// @dev Consolidates payouts into the target currency (opposite of the deposit currency).
+    /// Handles fee distribution and ensures payouts are in a single currency by swapping
+    /// when necessary. Makers receive proceeds in the target currency they were expecting.
+    /// @param poolManager The Uniswap V4 pool manager
+    /// @param key The pool key for the limit order
+    /// @param order The limit order storage struct containing order details
+    /// @param orderId The unique identifier for the limit order
+    /// @param feeRecipient The address to receive referral fees (address(0) if no fees)
+    /// @param coinIn The coin contract address for multi-hop swap paths (if applicable)
+    /// @param coinLookup The deployed coin version lookup contract
+    /// @param weth The WETH contract address for ETH handling
+    /// @return makerCoinOut The currency paid to the maker
+    /// @return makerAmountOut The amount paid to the maker
+    /// @return referralAmountOut The amount paid to the fee recipient
     function burnAndPayout(
         IPoolManager poolManager,
         PoolKey memory key,
@@ -82,6 +97,20 @@ library LimitOrderLiquidity {
         }
     }
 
+    /// @notice Burns limit order liquidity and refunds the proceeds to a recipient
+    /// @dev Consolidates payouts into the original deposit currency. If both currencies
+    /// have positive amounts after burning, the counter-asset is swapped into the original
+    /// deposit currency, ensuring the recipient receives a single consolidated payout.
+    /// @param poolManager The Uniswap V4 pool manager
+    /// @param key The pool key for the limit order
+    /// @param tickLower The lower tick of the limit order position
+    /// @param tickUpper The upper tick of the limit order position
+    /// @param liquidity The amount of liquidity to burn
+    /// @param salt The salt used for position identification
+    /// @param recipient The address to receive the refund
+    /// @param isCurrency0 True if the original deposit was in currency0, false if currency1
+    /// @param weth The WETH contract address for ETH handling
+    /// @return amountOut The total amount refunded in the original deposit currency
     function burnAndRefund(
         IPoolManager poolManager,
         PoolKey memory key,
@@ -95,20 +124,9 @@ library LimitOrderLiquidity {
     ) internal returns (uint128 amountOut) {
         (int128 amount0, int128 amount1) = _burnLiquidity(poolManager, key, tickLower, tickUpper, liquidity, salt);
 
-        if (amount0 > 0) {
-            uint128 amount0Out = uint128(amount0);
-            _takeCurrency(poolManager, key.currency0, recipient, amount0Out, weth);
-            if (isCurrency0) {
-                amountOut = amount0Out;
-            }
-        }
-        if (amount1 > 0) {
-            uint128 amount1Out = uint128(amount1);
-            _takeCurrency(poolManager, key.currency1, recipient, amount1Out, weth);
-            if (!isCurrency0) {
-                amountOut = amount1Out;
-            }
-        }
+        // Refund to original deposit currency (swaps any accumulated counter-asset)
+        Currency payoutCurrency = isCurrency0 ? key.currency0 : key.currency1;
+        (, amountOut) = _payoutRecipient(poolManager, recipient, amount0, amount1, _buildSingleHopPath(key, payoutCurrency), weth);
     }
 
     function settleDeltas(IPoolManager poolManager, PoolKey memory key, int256 d0, int256 d1, address payout0, address payout1) internal {
@@ -116,8 +134,13 @@ library LimitOrderLiquidity {
             poolManager.take(key.currency0, payout0, uint256(d0));
         }
         if (d0 < 0) {
-            uint256 amount = uint256(uint256(-d0));
+            // This is safe because d0 is always negative
+            //forge-lint: disable-next-line(unsafe-typecast)
+            uint256 amount = uint256(-d0);
             poolManager.sync(key.currency0);
+
+            // For native ETH, settle with value
+            // Ensured to be currency0 by token ordering
             if (key.currency0.isAddressZero()) {
                 poolManager.settle{value: amount}();
             } else {
@@ -127,17 +150,17 @@ library LimitOrderLiquidity {
         }
 
         if (d1 > 0 && payout1 != address(0)) {
+            // This is safe because d1 is always positive
+            //forge-lint: disable-next-line(unsafe-typecast)
             poolManager.take(key.currency1, payout1, uint256(d1));
         }
         if (d1 < 0) {
-            uint256 amount = uint256(uint256(-d1));
+            // This is safe because d1 is always negative
+            //forge-lint: disable-next-line(unsafe-typecast)
+            uint256 amount = uint256(-d1);
             poolManager.sync(key.currency1);
-            if (key.currency1.isAddressZero()) {
-                poolManager.settle{value: amount}();
-            } else {
-                key.currency1.transfer(address(poolManager), amount);
-                poolManager.settle();
-            }
+            key.currency1.transfer(address(poolManager), amount);
+            poolManager.settle();
         }
     }
 
@@ -178,8 +201,12 @@ library LimitOrderLiquidity {
         }
 
         // Fallback: construct simple single-hop path
-        Currency coinCurrency = payoutCurrency == key.currency0 ? key.currency1 : key.currency0;
-        payoutPath.currencyIn = coinCurrency;
+        return _buildSingleHopPath(key, payoutCurrency);
+    }
+
+    function _buildSingleHopPath(PoolKey memory key, Currency payoutCurrency) private pure returns (IHasSwapPath.PayoutSwapPath memory payoutPath) {
+        Currency inputCurrency = payoutCurrency == key.currency0 ? key.currency1 : key.currency0;
+        payoutPath.currencyIn = inputCurrency;
         payoutPath.path = new PathKey[](1);
         payoutPath.path[0] = PathKey({intermediateCurrency: payoutCurrency, fee: key.fee, tickSpacing: key.tickSpacing, hooks: key.hooks, hookData: bytes("")});
     }
@@ -192,15 +219,6 @@ library LimitOrderLiquidity {
         }
     }
 
-    function _settleNegativeDeltas(IPoolManager poolManager, PoolKey memory key, int128 amount0, int128 amount1) private {
-        int256 repay0 = amount0 < 0 ? int256(amount0) : int256(0);
-        int256 repay1 = amount1 < 0 ? int256(amount1) : int256(0);
-
-        if (repay0 != 0 || repay1 != 0) {
-            settleDeltas(poolManager, key, repay0, repay1, address(0), address(0));
-        }
-    }
-
     function _takeCurrency(IPoolManager poolManager, Currency currency, address recipient, uint128 amount, address weth) private {
         if (!currency.isAddressZero()) {
             poolManager.take(currency, recipient, amount);
@@ -222,15 +240,20 @@ library LimitOrderLiquidity {
         IHasSwapPath.PayoutSwapPath memory payoutPath,
         address weth
     ) private returns (Currency coinOut, uint128 amountOut) {
-        // Convert to uint128, treating negative/zero as zero
-        uint128 amt0 = amount0 > 0 ? uint128(amount0) : 0;
-        uint128 amt1 = amount1 > 0 ? uint128(amount1) : 0;
-
         // Use swapToPath which handles all cases:
         // - Single positive delta: returns that currency
         // - Dual positive deltas: swaps one to the other and returns combined amount
         // - Multi-hop paths: handles coin -> backingCoin -> backingCoin's currency
-        (coinOut, amountOut) = UniV4SwapToCurrency.swapToPath(poolManager, amt0, amt1, payoutPath.currencyIn, payoutPath.path);
+        (coinOut, amountOut) = UniV4SwapToCurrency.swapToPath(
+            poolManager,
+            // This is safe because amount0 and amount1 are only needed if positive in this function.
+            //forge-lint: disable-next-line(unsafe-typecast)
+            amount0 > 0 ? uint128(amount0) : 0,
+            //forge-lint: disable-next-line(unsafe-typecast)
+            amount1 > 0 ? uint128(amount1) : 0,
+            payoutPath.currencyIn,
+            payoutPath.path
+        );
 
         if (amountOut > 0) {
             Currency payoutCurrency = coinOut;

package/src/libs/LimitOrderWithdraw.sol

@@ -9,8 +9,6 @@ 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";
@@ -81,10 +79,8 @@ 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());
+        // Prevent withdrawal of crossed orders - they must be filled instead
+        require(!LimitOrderCommon.hasCrossed(order, LimitOrderCommon.currentPoolTick(poolManager, key)), IZoraLimitOrderBook.OrderFillable());
 
         int24 orderTick = LimitOrderCommon.getOrderTick(order);
         coin = LimitOrderCommon.getOrderCoin(key, order.isCurrency0);

package/src/libs/SwapLimitOrders.sol

@@ -104,13 +104,12 @@ library SwapLimitOrders {
             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) {
+        // Skip order creation when at hard price boundaries
+        // For currency0 (buy orders): cannot place if price is at max
+        // For currency1 (sell orders): cannot place if price is at min
+        uint160 maxPrice = TickMath.MAX_SQRT_PRICE - 1;
+        uint160 minPrice = TickMath.MIN_SQRT_PRICE + 1;
+        if (isCurrency0 ? sqrtPriceX96 >= maxPrice : sqrtPriceX96 <= minPrice) {
             unallocated = totalSize;
             return (o, allocated, unallocated);
         }
@@ -129,7 +128,11 @@ library SwapLimitOrders {
             uint256 orderSize = FullMath.mulDiv(uint256(remaining), config.percentages[i], PERCENT_SCALE);
             if (orderSize == 0) continue;
 
+            // This is safe because orderSize is bounded by remaining which is uint128
+            //forge-lint: disable-next-line(unsafe-typecast)
             allocated += uint128(orderSize);
+            // This is safe because orderSize is bounded by remaining which is uint128
+            //forge-lint: disable-next-line(unsafe-typecast)
             remaining -= uint128(orderSize);
 
             int24 targetTick = _tickForMultiple(key, isCurrency0, baseTick, sqrtPriceX96, config.multiples[i]);
@@ -139,6 +142,7 @@ library SwapLimitOrders {
             o.multiples[count] = config.multiples[i];
             o.percentages[count] = config.percentages[i];
 
+            // This is safe because orderCount is validated to be an array length which cannot overflow by definition
             unchecked {
                 ++count;
             }
@@ -179,6 +183,8 @@ library SwapLimitOrders {
         uint256 scaled = FullMath.mulDiv(uint256(sqrtPriceX96), sqrtMultiplier, SQRT_MULTIPLE_SCALE);
         if (scaled > type(uint160).max) scaled = type(uint160).max;
 
+        // This is safe because scaled is always less than type(uint160).max
+        //forge-lint: disable-next-line(unsafe-typecast)
         int24 rawTick = TickMath.getTickAtSqrtPrice(uint160(scaled));
         aligned = DopplerMath.alignTickToTickSpacing(isCurrency0, rawTick, key.tickSpacing);
 

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,7 +26,8 @@ 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 {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
@@ -35,7 +37,7 @@ import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.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 {
+contract SwapWithLimitOrders is ISetLimitOrderConfig, Ownable2Step, IMsgSender {
     using SafeERC20 for IERC20;
     using BalanceDeltaLibrary for BalanceDelta;
     using CurrencyLibrary for Currency;
@@ -43,6 +45,7 @@ contract SwapWithLimitOrders is IMsgSender {
     using Path for bytes;
 
     /// @notice The Uniswap V4 pool manager
+    // forge-lint-ignore screaming-snake-case-immutable
     IPoolManager public immutable poolManager;
 
     /// @notice The limit order book contract
@@ -121,9 +124,6 @@ contract SwapWithLimitOrders is IMsgSender {
     /// @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();
 
@@ -141,7 +141,8 @@ contract SwapWithLimitOrders is IMsgSender {
     /// @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_) {
+    /// @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");
@@ -159,10 +160,9 @@ contract SwapWithLimitOrders is IMsgSender {
     }
 
     /// @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);