@zoralabs/limit-orders 0.2.1 → 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";
@@ -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,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/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;
@@ -121,9 +123,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 +140,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 +159,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);