@zoralabs/limit-orders 0.2.0

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@zoralabs/limit-orders",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "5.4.0",
+    "@openzeppelin/contracts-upgradeable": "5.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.1.2",
+    "@wagmi/cli": "^1.0.1",
+    "@solidity-parser/parser": "0.19.0",
+    "@uniswap/v4-core": "https://github.com/Uniswap/v4-core#a7cf038cd568801a79a9b4cf92cd5b52c95c8585",
+    "@uniswap/v4-periphery": "https://github.com/Uniswap/v4-periphery#eeb3eff28dd5f5f17aa94180fa3610ff59b0e1c8",
+    "@uniswap/universal-router": "https://github.com/Uniswap/universal-router#3663f6db6e2fe121753cd2d899699c2dc75dca86",
+    "@uniswap/permit2": "https://github.com/Uniswap/permit2#cc56ad0f3439c502c246fc5cfcc3db92bb8b7219",
+    "ds-test": "https://github.com/dapphub/ds-test#cd98eff28324bfac652e63a239a60632a761790b",
+    "forge-std": "https://github.com/foundry-rs/forge-std#v1.9.1",
+    "prettier": "^3.0.3",
+    "prettier-plugin-solidity": "^1.4.1",
+    "solady": "0.0.132",
+    "solmate": "6.8.0",
+    "tsup": "^7.2.0",
+    "tsx": "^3.13.0",
+    "typescript": "^5.2.2",
+    "viem": "^2.21.18",
+    "@zoralabs/shared-contracts": "^0.0.5",
+    "@zoralabs/shared-scripts": "^0.0.0",
+    "@zoralabs/coins": "^2.4.1",
+    "@zoralabs/tsconfig": "^0.0.1"
+  },
+  "scripts": {
+    "build": "forge build",
+    "build:contracts:minimal": "forge build src/ --no-metadata",
+    "build:js": "pnpm run wagmi:generate && pnpm run copy-abis && pnpm run prettier:write && tsup",
+    "build:sizes": "forge build src/ --sizes",
+    "copy-abis": "pnpm exec bundle-abis",
+    "coverage": "forge coverage --report lcov --ir-minimum --no-match-coverage '(test/)'",
+    "prettier:check": "prettier --check 'src/**/*.sol' 'test/**/*.sol'",
+    "prettier:write": "prettier --write 'src/**/*.sol' 'test/**/*.sol'",
+    "test": "forge test -vv",
+    "test-gas": "forge test --gas-report",
+    "update-contract-version": "pnpm exec update-contract-version",
+    "wagmi:generate": "pnpm run build:contracts:minimal && wagmi generate && pnpm exec rename-generated-abi-casing ./package/wagmiGenerated.ts"
+  }
+}

package/remappings.txt

@@ -0,0 +1,11 @@
+ds-test/=node_modules/ds-test/src/
+forge-std/=node_modules/forge-std/src/
+@openzeppelin/=node_modules/@openzeppelin/
+@zoralabs/shared-contracts/=node_modules/@zoralabs/shared-contracts/src/
+solady/=node_modules/solady/src/ 
+@uniswap/v4-core/=node_modules/@uniswap/v4-core/
+@uniswap/v4-periphery/=node_modules/@uniswap/v4-periphery/
+permit2/src/=node_modules/@uniswap/permit2/src/
+@uniswap/universal-router/contracts/=node_modules/@uniswap/universal-router/contracts/
+solmate/=node_modules/solmate/src/
+@zoralabs/coins/=node_modules/@zoralabs/coins/

package/src/IZoraLimitOrderBook.sol

@@ -0,0 +1,195 @@
+// 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.23;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {IZoraLimitOrderBookCoinsInterface} from "@zoralabs/coins/src/interfaces/IZoraLimitOrderBookCoinsInterface.sol";
+
+interface IZoraLimitOrderBook is IZoraLimitOrderBookCoinsInterface {
+    struct OrderBatch {
+        PoolKey key;
+        bool isCurrency0;
+        bytes32[] orderIds;
+    }
+
+    /// @dev Callback ids for the V4 pool manager
+    enum CallbackId {
+        CREATE,
+        FILL,
+        WITHDRAW_ORDERS
+    }
+
+    /// @dev Data echoed back to hooks when create flows resolve
+    struct CreateCallbackData {
+        PoolKey key;
+        bool isCurrency0;
+        uint256[] orderSizes;
+        int24[] orderTicks;
+        address maker;
+    }
+
+    /// @dev Data forwarded when the pool manager triggers a fill.
+    struct FillCallbackData {
+        PoolKey poolKey;
+        bool isCurrency0;
+        int24 startTick;
+        int24 endTick;
+        uint256 maxFillCount;
+        address fillReferral;
+        bytes32[] orderIds;
+    }
+
+    /// @dev Data used to withdraw from a maker's individual orders
+    struct WithdrawOrdersCallbackData {
+        address maker;
+        bytes32[] orderIds;
+        address coin;
+        uint256 minAmountOut;
+        address recipient;
+    }
+
+    /// @notice Emitted when a new order joins a tick queue.
+    event LimitOrderCreated(
+        address indexed maker,
+        address indexed coin,
+        bytes32 poolKeyHash,
+        bool isCurrency0,
+        int24 orderTick, // The tick at which the limit order is placed
+        int24 currentTick, // The current tick of the pool when the order was created
+        uint128 orderSize,
+        bytes32 orderId
+    );
+
+    /// @notice Emitted when an order is amended or marked inactive.
+    event LimitOrderUpdated(
+        address indexed maker,
+        address indexed coin,
+        bytes32 poolKeyHash,
+        bool isCurrency0,
+        int24 tick,
+        uint128 orderSize,
+        bytes32 orderId,
+        bool isCancelled
+    );
+
+    /// @notice Emitted when an order is filled and removed from the book.
+    event LimitOrderFilled(
+        address indexed maker,
+        address indexed coinIn,
+        address coinOut,
+        uint128 amountIn,
+        uint128 amountOut,
+        address fillReferral,
+        uint128 fillReferralAmount,
+        bytes32 poolKeyHash,
+        int24 tick,
+        bytes32 orderId
+    );
+
+    /// @notice Emitted when a maker's aggregate balance for a coin changes.
+    event MakerBalanceUpdated(address indexed maker, address indexed coin, uint256 newBalance);
+
+    /// @notice Caller must be a registered Zora hook.
+    error OnlyZoraHook();
+    /// @notice Caller must be the configured pool manager.
+    error NotPoolManager();
+    /// @notice Input arrays must have equal length.
+    error ArrayLengthMismatch();
+    /// @notice Orders must specify a non-zero size.
+    error ZeroOrderSize();
+    /// @notice Maker address cannot be zero.
+    error ZeroMaker();
+    /// @notice Supplied ETH must match expected amount.
+    error NativeValueMismatch();
+    /// @notice Forwarded funds from hook were insufficient.
+    error InsufficientForwardedFunds();
+    /// @notice Transfer in of funds failed or was insufficient.
+    error InsufficientTransferFunds();
+    /// @notice Fill requests must cap the number of orders processed.
+    error MaxFillCountCannotBeZero();
+    /// @notice Referenced pool key hash is unknown.
+    error InvalidPoolKey();
+    /// @notice Tick range inputs were invalid or misaligned.
+    error InvalidFillWindow(int24 startTick, int24 endTick, bool isCurrency0);
+    /// @notice Address argument was zero.
+    error AddressZero();
+    /// @notice Order id was not found.
+    error InvalidOrder();
+    /// @notice Operation attempted by non-maker.
+    error OrderNotMaker();
+    /// @notice Order is no longer open.
+    error OrderClosed();
+    /// @notice Callback realized zero fills when one was expected.
+    error ZeroRealizedOrder();
+    /// @notice Unlock callback id was not recognized.
+    error UnknownCallback();
+    /// @notice Router caller failed to expose the original message sender.
+    error RouterMsgSenderInvalid();
+    /// @notice Non-hook caller attempted to fill orders while pool is unlocked.
+    error UnlockedFillNotAllowed();
+    /// @notice Withdrawal did not reach minimum amount threshold.
+    error MinAmountNotReached(uint256 withdrawn, uint256 minAmountOut);
+    /// @notice Order coin does not match expected coin for batch withdrawal.
+    error CoinMismatch(bytes32 orderId, address expectedCoin, address actualCoin);
+
+    /// @notice Creates limit orders, pulling funds from msg.sender when pool manager is locked, or using funds already in manager when unlocked.
+    /// @dev This function is access-controlled via OpenZeppelin's AccessManager. The caller must have the appropriate role
+    ///      as configured in the AccessManager contract. Initially, this can be set to PUBLIC_ROLE to allow anyone to create orders,
+    ///      or it can be restricted to specific addresses/roles for permissioned operation.
+    /// @param key Pool key specifying currency pair and tick spacing.
+    /// @param isCurrency0 Whether the orders are denominated in currency0.
+    /// @param orderSizes Order liquidity sizes.
+    /// @param orderTicks Corresponding ticks.
+    /// @param maker Address of the maker who will own the orders.
+    /// @return orderIds Deterministic order identifiers.
+    function create(
+        PoolKey memory key,
+        bool isCurrency0,
+        uint256[] memory orderSizes,
+        int24[] memory orderTicks,
+        address maker
+    ) external payable returns (bytes32[] memory orderIds);
+
+    /// @notice Fills limit orders within a tick window.
+    /// @param key Pool key whose orders should be processed.
+    /// @param isCurrency0 Whether currency0 orders are targeted; otherwise currency1.
+    /// @param startTick Inclusive starting tick. Use `-type(int24).max` for the default lower bound.
+    /// @param endTick Inclusive ending tick. Use `type(int24).max` for the default upper bound.
+    /// @param maxFillCount Maximum orders to fill in this pass.
+    /// @param fillReferral Address to receive accrued LP fees; use address(0) to give fees to maker.
+    function fill(PoolKey calldata key, bool isCurrency0, int24 startTick, int24 endTick, uint256 maxFillCount, address fillReferral) external;
+
+    /// @notice Fills explicit order ids grouped by pool.
+    /// @param batches Array of per-pool batches containing order ids to process.
+    /// @param fillReferral Address to receive accrued LP fees; use address(0) to give fees to maker.
+    function fill(OrderBatch[] calldata batches, address fillReferral) external;
+
+    /// @notice Cancels orders and withdraws resulting funds to a recipient.
+    /// @dev Orders are cancelled sequentially until minAmountOut is reached.
+    ///      If minAmountOut is 0, all provided orders are cancelled.
+    ///      Reverts if total withdrawn is less than minAmountOut.
+    /// @param orderIds Order identifiers to cancel.
+    /// @param coin The coin address that all orders must match (use address(0) for native ETH).
+    /// @param minAmountOut Minimum amount to withdraw (0 = cancel all provided orders).
+    /// @param recipient Destination for returned assets.
+    function withdraw(bytes32[] calldata orderIds, address coin, uint256 minAmountOut, address recipient) external;
+
+    /// @notice Returns the aggregate balance of open orders for a maker/coin pair.
+    /// @param maker Address of the maker.
+    /// @param coin Address of the coin (use address(0) for native ETH).
+    /// @return balance Total value of open orders.
+    function balanceOf(address maker, address coin) external view returns (uint256 balance);
+
+    function getMaxFillCount() external view returns (uint256);
+
+    /// @notice Sets the maximum number of orders that can be filled in a single fill operation.
+    /// @dev This function is access-controlled via OpenZeppelin's AccessManager. The caller must have the appropriate role
+    ///      as configured in the AccessManager contract.
+    /// @param maxFillCount The new maximum fill count value.
+    function setMaxFillCount(uint256 maxFillCount) external;
+}

package/src/ZoraLimitOrderBook.sol

@@ -0,0 +1,220 @@
+// 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 {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";
+import {IZoraLimitOrderBook} from "./IZoraLimitOrderBook.sol";
+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 {LimitOrderTypes} from "./libs/LimitOrderTypes.sol";
+
+contract ZoraLimitOrderBook is IZoraLimitOrderBook, SimpleAccessManaged {
+    IPoolManager public immutable poolManager;
+    IDeployedCoinVersionLookup public immutable zoraCoinVersionLookup;
+    IZoraHookRegistry public immutable zoraHookRegistry;
+
+    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;
+    }
+
+    /// @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];
+    }
+
+    function getMakerNonce(address maker) internal view returns (uint256) {
+        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,
+        bool isCurrency0,
+        uint256[] memory orderSizes,
+        int24[] memory orderTicks,
+        address maker
+    ) external payable override returns (bytes32[] memory) {
+        _checkCanCall(this.create.selector);
+        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();
+        }
+
+        bool isUnlocked = TransientStateLibrary.isUnlocked(poolManager);
+
+        // Only known Zora hooks can fill while unlocked
+        if (isUnlocked) {
+            require(zoraHookRegistry.isRegisteredHook(msg.sender), UnlockedFillNotAllowed());
+        }
+
+        LimitOrderStorage.Layout storage state = LimitOrderStorage.layout();
+        LimitOrderFill.Context memory ctx = _fillContext();
+
+        (PoolKey memory canonicalKey, int24 resolvedStart, int24 resolvedEnd) = LimitOrderFill.validateTickRange(
+            state,
+            ctx,
+            key,
+            isCurrency0,
+            startTick,
+            endTick
+        );
+
+        IZoraLimitOrderBook.FillCallbackData memory fillData = _fillData(
+            canonicalKey,
+            isCurrency0,
+            resolvedStart,
+            resolvedEnd,
+            maxFillCount,
+            fillReferral,
+            new bytes32[](0)
+        );
+
+        if (isUnlocked) {
+            // fill while already unlocked
+            LimitOrderFill.executeFill(state, ctx, fillData);
+            return;
+        }
+
+        // unlock and fill
+        _unlock(IZoraLimitOrderBook.CallbackId.FILL, abi.encode(fillData));
+    }
+
+    function fill(OrderBatch[] calldata batches, address fillReferral) external override {
+        uint256 length = batches.length;
+        for (uint256 i = 0; i < length; ++i) {
+            OrderBatch calldata batch = batches[i];
+
+            if (batch.orderIds.length != 0) {
+                bytes32[] memory orderIds = batch.orderIds;
+                _unlock(
+                    IZoraLimitOrderBook.CallbackId.FILL,
+                    abi.encode(_fillData(batch.key, batch.isCurrency0, 0, 0, orderIds.length, fillReferral, orderIds))
+                );
+            }
+        }
+    }
+
+    /// @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));
+    }
+
+    /// @notice Processes pool-manager unlock callbacks and routes them to the correct handler.
+    /// @param data ABI encoded callback identifier and callback data.
+    /// @return result Optional return data for create flows.
+    function unlockCallback(bytes calldata data) external returns (bytes memory) {
+        require(msg.sender == address(poolManager), NotPoolManager());
+
+        (CallbackId callbackId, bytes memory callbackData) = abi.decode(data, (CallbackId, bytes));
+        LimitOrderStorage.Layout storage state = LimitOrderStorage.layout();
+
+        if (callbackId == CallbackId.CREATE) {
+            return LimitOrderCreate.handleCreateCallback(state, poolManager, callbackData);
+        }
+
+        if (callbackId == CallbackId.FILL) {
+            LimitOrderFill.handleFillCallback(state, _fillContext(), callbackData);
+        } else if (callbackId == CallbackId.WITHDRAW_ORDERS) {
+            LimitOrderWithdraw.handleWithdrawOrdersCallback(state, poolManager, callbackData);
+        } else {
+            revert UnknownCallback();
+        }
+
+        return bytes("");
+    }
+
+    function getMaxFillCount() public view returns (uint256) {
+        return LimitOrderStorage.layout().maxFillCount;
+    }
+
+    function setMaxFillCount(uint256 maxFillCount) external {
+        _checkCanCall(this.setMaxFillCount.selector);
+
+        LimitOrderStorage.layout().maxFillCount = maxFillCount;
+    }
+
+    receive() external payable {
+        require(msg.sender == address(poolManager), NotPoolManager());
+    }
+
+    function _fillContext() private view returns (LimitOrderFill.Context memory ctx) {
+        ctx.poolManager = poolManager;
+        ctx.versionLookup = zoraCoinVersionLookup;
+    }
+
+    function _fillData(
+        PoolKey memory key,
+        bool isCurrency0,
+        int24 startTick,
+        int24 endTick,
+        uint256 maxFillCount,
+        address fillReferral,
+        bytes32[] memory orderIds
+    ) private pure returns (IZoraLimitOrderBook.FillCallbackData memory data) {
+        data.poolKey = key;
+        data.isCurrency0 = isCurrency0;
+        data.startTick = startTick;
+        data.endTick = endTick;
+        data.maxFillCount = maxFillCount;
+        data.fillReferral = fillReferral;
+        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/SimpleAccessManaged.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {IAuthority} from "@openzeppelin/contracts/access/manager/IAuthority.sol";
+
+/**
+ * @dev This contract module makes a contract "access managed", allowing an authority
+ * contract to control access to specific functions.
+ *
+ * This is a simplified version of OpenZeppelin's AccessManaged that removes time-based
+ * access control features (delays, scheduled operations) and only supports immediate
+ * access checks.
+ *
+ * The authority is set during construction and can only be changed by the current authority.
+ */
+abstract contract SimpleAccessManaged {
+    /// @dev Thrown when an unauthorized caller attempts to access a restricted function
+    error AccessManagedUnauthorized();
+
+    /// @dev Thrown when trying to set an invalid authority (e.g., not a contract)
+    error AccessManagedInvalidAuthority(address authority);
+
+    address private _authority;
+
+    /// @dev Emitted when the authority is updated
+    event AuthorityUpdated(address authority);
+
+    /**
+     * @dev Initializes the contract with an initial authority.
+     * @param initialAuthority The address of the authority contract
+     */
+    constructor(address initialAuthority) {
+        _setAuthority(initialAuthority);
+    }
+
+    /**
+     * @dev Returns the current authority address.
+     * @return The address of the authority contract
+     */
+    function authority() public view virtual returns (address) {
+        return _authority;
+    }
+
+    /**
+     * @dev Transfers control of the contract to a new authority.
+     * Can only be called by the current authority.
+     * @param newAuthority The address of the new authority contract
+     */
+    function setAuthority(address newAuthority) public virtual {
+        if (msg.sender != authority()) {
+            revert AccessManagedUnauthorized();
+        }
+        if (newAuthority.code.length == 0) {
+            revert AccessManagedInvalidAuthority(newAuthority);
+        }
+        _setAuthority(newAuthority);
+    }
+
+    /**
+     * @dev Internal function to set the authority without access checks.
+     * @param newAuthority The address of the new authority contract
+     */
+    function _setAuthority(address newAuthority) internal virtual {
+        _authority = newAuthority;
+        emit AuthorityUpdated(newAuthority);
+    }
+
+    /**
+     * @dev Internal function to check if a caller can execute a function.
+     * Reverts with AccessManagedUnauthorized if the caller is not authorized.
+     * @param selector The function selector being called
+     */
+    function _checkCanCall(bytes4 selector) internal view virtual {
+        require(IAuthority(authority()).canCall(msg.sender, address(this), selector), AccessManagedUnauthorized());
+    }
+}