@zoralabs/limit-orders 0.2.0 → 0.2.2

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";
@@ -19,21 +18,26 @@ import {LimitOrderStorage} from "./libs/LimitOrderStorage.sol";
 import {LimitOrderCreate} from "./libs/LimitOrderCreate.sol";
 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 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());
 
-    constructor(address poolManager_, address zoraCoinVersionLookup_, address zoraHookRegistry_, address authority_) SimpleAccessManaged(authority_) {
         poolManager = IPoolManager(poolManager_);
         zoraCoinVersionLookup = IDeployedCoinVersionLookup(zoraCoinVersionLookup_);
         zoraHookRegistry = IZoraHookRegistry(zoraHookRegistry_);
-    }
-
-    function tickQueueBalance(bytes32 poolKeyHash, address coin, int24 tick) internal view returns (uint256) {
-        return LimitOrderStorage.layout().tickQueues[poolKeyHash][coin][tick].balance;
+        weth = weth_;
     }
 
     /// @inheritdoc IZoraLimitOrderBook
@@ -41,18 +45,10 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         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];
     }
@@ -61,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.encodePacked(poolKeyHash, coin, tick, maker, nonce));
-    }
-
     /// @inheritdoc IZoraLimitOrderBook
     function create(
         PoolKey memory key,
@@ -72,15 +64,15 @@ 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);
     }
 
     /// @inheritdoc IZoraLimitOrderBook
     function fill(PoolKey calldata key, bool isCurrency0, int24 startTick, int24 endTick, uint256 maxFillCount, address fillReferral) external override {
-        if (maxFillCount == 0) {
-            maxFillCount = getMaxFillCount();
+        uint256 defaultMaxFillCount = getMaxFillCount();
+        if (maxFillCount == 0 || maxFillCount > defaultMaxFillCount) {
+            maxFillCount = defaultMaxFillCount;
         }
 
         bool isUnlocked = TransientStateLibrary.isUnlocked(poolManager);
@@ -93,9 +85,9 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         LimitOrderStorage.Layout storage state = LimitOrderStorage.layout();
         LimitOrderFill.Context memory ctx = _fillContext();
 
-        (PoolKey memory canonicalKey, int24 resolvedStart, int24 resolvedEnd) = LimitOrderFill.validateTickRange(
+        (PoolKey memory canonicalKey, int24 resolvedStart, int24 resolvedEnd) = LimitOrderViews.validateTickRange(
             state,
-            ctx,
+            ctx.poolManager,
             key,
             isCurrency0,
             startTick,
@@ -139,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.
@@ -159,7 +153,7 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
         if (callbackId == CallbackId.FILL) {
             LimitOrderFill.handleFillCallback(state, _fillContext(), callbackData);
         } else if (callbackId == CallbackId.WITHDRAW_ORDERS) {
-            LimitOrderWithdraw.handleWithdrawOrdersCallback(state, poolManager, callbackData);
+            LimitOrderWithdraw.handleWithdrawOrdersCallback(state, poolManager, weth, callbackData);
         } else {
             revert UnknownCallback();
         }
@@ -171,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;
     }
 
@@ -184,6 +176,7 @@ contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
     function _fillContext() private view returns (LimitOrderFill.Context memory ctx) {
         ctx.poolManager = poolManager;
         ctx.versionLookup = zoraCoinVersionLookup;
+        ctx.weth = weth;
     }
 
     function _fillData(
@@ -204,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,41 @@
+// 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() {
+        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

@@ -27,57 +27,6 @@ library LimitOrderBitmap {
         }
     }
 
-    function getExecutableTicks(
-        mapping(int16 => uint256) storage bm,
-        mapping(int24 => LimitOrderTypes.Queue) storage poolQueue,
-        int24 tickSpacing,
-        bool zeroForOne,
-        int24 tickBeforeSwap,
-        int24 tickAfterSwap
-    ) internal view returns (int24[] memory) {
-        uint256 numTicksCrossed = uint256(int256(_abs(tickBeforeSwap - tickAfterSwap)));
-        uint256 numTicksToCheck = numTicksCrossed / uint256(int256(tickSpacing)) + 1;
-
-        int24[] memory ticksToCheck = new int24[](numTicksToCheck);
-        uint256 numExecutableTicks;
-
-        int24 targetTick = tickAfterSwap;
-        int24 currentTick = tickBeforeSwap;
-
-        while (true) {
-            if (zeroForOne ? currentTick <= targetTick : currentTick >= targetTick) {
-                break;
-            }
-
-            (int24 nextInitializedTick, bool initialized) = TickBitmap.nextInitializedTickWithinOneWord(bm, currentTick, tickSpacing, zeroForOne);
-
-            bool crossesTarget = zeroForOne ? nextInitializedTick <= targetTick : nextInitializedTick > targetTick;
-
-            if (crossesTarget) {
-                nextInitializedTick = targetTick;
-                initialized = false;
-            }
-
-            if (initialized) {
-                if (poolQueue[nextInitializedTick].length > 0) {
-                    ticksToCheck[numExecutableTicks++] = nextInitializedTick;
-                }
-            }
-
-            if (nextInitializedTick == targetTick) {
-                break;
-            }
-
-            currentTick = zeroForOne ? nextInitializedTick - 1 : nextInitializedTick;
-        }
-
-        assembly {
-            mstore(ticksToCheck, numExecutableTicks)
-        }
-
-        return ticksToCheck;
-    }
-
     function _abs(int24 x) private pure returns (int24) {
         return x < 0 ? -x : x;
     }

package/src/libs/LimitOrderCommon.sol

@@ -15,12 +15,13 @@ import {LimitOrderStorage} from "./LimitOrderStorage.sol";
 import {LimitOrderTypes} from "./LimitOrderTypes.sol";
 import {LimitOrderQueues} from "./LimitOrderQueues.sol";
 import {LimitOrderBitmap} from "./LimitOrderBitmap.sol";
+import {LimitOrderCreate} from "./LimitOrderCreate.sol";
 
 library LimitOrderCommon {
-    /// @dev Currency0 orders are executed when the price rises to the lower tick.
-    ///      Currency1 orders are executed when the price falls to the upper tick.
+    /// @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) {
-        return order.isCurrency0 ? order.tickLower : order.tickUpper;
+        return order.isCurrency0 ? order.tickUpper : order.tickLower;
     }
 
     function getOrderCoin(PoolKey memory key, bool isCurrency0) internal pure returns (address) {
@@ -29,42 +30,59 @@ library LimitOrderCommon {
 
     function recordCreation(
         LimitOrderStorage.Layout storage state,
-        PoolKey memory key,
-        bytes32 poolKeyHash,
-        bytes32 orderId,
-        address maker,
-        address coin,
-        bool isCurrency0,
+        LimitOrderCreate.CreateContext memory ctx,
+        LimitOrderCreate.MintParams memory mintParams,
         int24 orderTick,
-        int24 currentTick,
-        uint256 epoch,
-        uint128 liquidity,
-        uint128 realizedSize,
-        int24 tickLower,
-        int24 tickUpper
+        uint128 realizedSize
     ) internal {
-        LimitOrderTypes.LimitOrder storage order = state.limitOrders[orderId];
+        _initializeOrder(state.limitOrders[mintParams.orderId], ctx, mintParams, realizedSize);
+        _addToQueue(state, ctx, mintParams, orderTick, realizedSize);
+        _updateMakerBalanceAndEmit(state, ctx, mintParams.orderId, orderTick, realizedSize);
+    }
+
+    function _initializeOrder(
+        LimitOrderTypes.LimitOrder storage order,
+        LimitOrderCreate.CreateContext memory ctx,
+        LimitOrderCreate.MintParams memory mintParams,
+        uint128 realizedSize
+    ) private {
         order.orderSize = realizedSize;
-        order.liquidity = liquidity;
-        order.tickLower = tickLower;
-        order.tickUpper = tickUpper;
-        order.createdEpoch = uint32(epoch);
+        order.liquidity = mintParams.liquidity;
+        order.tickLower = mintParams.tickLower;
+        order.tickUpper = mintParams.tickUpper;
+        order.createdEpoch = uint32(ctx.epoch);
         order.status = LimitOrderTypes.OrderStatus.OPEN;
-        order.isCurrency0 = isCurrency0;
-        order.maker = maker;
-        order.poolKeyHash = poolKeyHash;
+        order.isCurrency0 = ctx.isCurrency0;
+        order.maker = ctx.maker;
+        order.poolKeyHash = ctx.poolKeyHash;
+    }
 
-        LimitOrderTypes.Queue storage tickQueue = state.tickQueues[poolKeyHash][coin][orderTick];
+    function _addToQueue(
+        LimitOrderStorage.Layout storage state,
+        LimitOrderCreate.CreateContext memory ctx,
+        LimitOrderCreate.MintParams memory mintParams,
+        int24 orderTick,
+        uint128 realizedSize
+    ) private {
+        LimitOrderTypes.Queue storage tickQueue = state.tickQueues[ctx.poolKeyHash][ctx.coin][orderTick];
         tickQueue.balance += realizedSize;
 
-        LimitOrderBitmap.setIfFirst(state.tickBitmaps[poolKeyHash][coin], orderTick, key.tickSpacing, tickQueue.length);
-        LimitOrderQueues.enqueue(tickQueue, state.limitOrders, orderId);
+        LimitOrderBitmap.setIfFirst(state.tickBitmaps[ctx.poolKeyHash][ctx.coin], orderTick, mintParams.key.tickSpacing, tickQueue.length);
+        LimitOrderQueues.enqueue(tickQueue, state.limitOrders, mintParams.orderId);
+    }
 
-        uint256 newMakerBalance = state.makerBalances[maker][coin] + realizedSize;
-        state.makerBalances[maker][coin] = newMakerBalance;
+    function _updateMakerBalanceAndEmit(
+        LimitOrderStorage.Layout storage state,
+        LimitOrderCreate.CreateContext memory ctx,
+        bytes32 orderId,
+        int24 orderTick,
+        uint128 realizedSize
+    ) private {
+        uint256 newMakerBalance = state.makerBalances[ctx.maker][ctx.coin] + realizedSize;
+        state.makerBalances[ctx.maker][ctx.coin] = newMakerBalance;
 
-        emit IZoraLimitOrderBook.LimitOrderCreated(maker, coin, poolKeyHash, isCurrency0, orderTick, currentTick, realizedSize, orderId);
-        emit IZoraLimitOrderBook.MakerBalanceUpdated(maker, coin, newMakerBalance);
+        emit IZoraLimitOrderBook.LimitOrderCreated(ctx.maker, ctx.coin, ctx.poolKeyHash, ctx.isCurrency0, orderTick, ctx.currentTick, realizedSize, orderId);
+        emit IZoraLimitOrderBook.MakerBalanceUpdated(ctx.maker, ctx.coin, newMakerBalance);
     }
 
     function removeOrder(

package/src/libs/LimitOrderCreate.sol

@@ -17,6 +17,7 @@ import {LimitOrderStorage} from "./LimitOrderStorage.sol";
 import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.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 {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
 import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
@@ -71,7 +72,6 @@ library LimitOrderCreate {
 
     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);
 
@@ -159,8 +159,10 @@ library LimitOrderCreate {
         }
 
         (int24 tickLower, int24 tickUpper) = _calculateTickRange(ctx.isCurrency0, orderTick, key.tickSpacing);
+        // Record the tick where the order becomes fillable
+        orderTick = ctx.isCurrency0 ? tickUpper : tickLower;
 
-        uint128 liquidity = LimitOrderLiquidity.liquidityForOrder(ctx.isCurrency0, orderSize, tickLower, tickUpper);
+        uint128 liquidity = LimitOrderViews.liquidityForOrder(ctx.isCurrency0, orderSize, tickLower, tickUpper);
         require(liquidity != 0, IZoraLimitOrderBook.ZeroRealizedOrder());
 
         orderId = _generateOrderId(ctx.poolKeyHash, ctx.coin, orderTick, ctx.maker, ++state.makerNonces[ctx.maker]);
@@ -212,22 +214,7 @@ library LimitOrderCreate {
             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
-        );
+        LimitOrderCommon.recordCreation(state, ctx, mintParams, orderTick, realized);
     }
 
     function _mintLiquidity(IPoolManager poolManager, bool isCurrency0, MintParams memory params) private returns (uint128 realizedSize, uint128 refunded) {