AsyncFiller

uint64 internal constant MAX_PRIORITY_FEE = type(uint64).max;

uint64 internal constant MIN_PRIORITY_FEE = 100_000;

uint256 internal constant PRIORITY_FEE_BPS = 10;

uint256 internal constant TRADE_FEE_BPS = 2;

function addOrder(
        State storage self,
        Book storage book,
        bytes32 id,
        address owner,
        uint256 amountIn,
        uint256 amountOutMin,
        bool isBuy,
        bool zeroForOne,
        uint256 priorityFee
    ) internal;

function tradeFee(uint256 amount) internal pure returns (uint256);

function minPriorityFee(uint256 notional) internal pure returns (uint256);

function minPriorityFee(uint256 notional, uint64 cap) internal pure returns (uint256);

function checkMinimum(Book storage book, bool isBuy, uint256 amountIn, uint256 amountOutMin) internal view;

function settlePriorityFee(
        State storage self,
        PoolKey memory key,
        bytes32 id,
        address maker,
        uint256 amount,
        address hook
    ) internal;

function bestOrder(State storage self, Book storage book, bool isBuy)
        internal
        view
        returns (bool found, uint128 price, bytes32 orderId, address owner);

function level(Book storage book, bool isBuy, uint128 price)
        internal
        view
        returns (bytes32 head, bytes32 tail, uint32 orderCount);

function bestAtPrice(Book storage book, bool isBuy, uint128 price) internal view returns (bytes32 id);

function updatePrice(
        State storage self,
        Book storage book,
        AsyncOrder memory order,
        bytes32 id,
        uint256 newAmountOutMin,
        address caller
    ) internal;

function fill(
        State storage self,
        Book storage book,
        AsyncOrder memory order,
        bytes32 id,
        address hook,
        address executor,
        address filler,
        address feeVault,
        uint256 fee
    ) internal;

function _payFiller(
        State storage self,
        Currency input,
        address hook,
        address filler,
        address feeVault,
        uint256 amountIn
    ) private returns (uint256 tradeFeeIn);

function _closeOrder(State storage self, Book storage book, PoolKey memory key, bytes32 id, address hook) private;

function settleOrderPriorityFee(State storage self, PoolKey memory key, bytes32 id, address hook) internal;

function cancel(
        State storage self,
        Book storage book,
        AsyncOrder memory order,
        bytes32 id,
        address hook,
        address executor
    ) internal;

function _append(State storage self, Book storage book, bytes32 id) internal;

function _remove(State storage self, Book storage book, bytes32 id) internal;

function _priorityKey(uint64 priorityFee, uint64 sequence) private pure returns (uint128);

function refreshExactPrice(State storage self, Book storage book, bytes32 id) internal;

function exactPrice(OrderInfo storage order) internal view returns (EligiblePrice.Ratio memory);

function eligibleAtPrice(Book storage book, bool isBuy, uint128 price, EligiblePrice.Ratio memory limit)
        internal
        view
        returns (bytes32);

function mostPermissiveAtPrice(Book storage book, bool isBuy, uint128 price)
        internal
        view
        returns (EligiblePrice.Ratio memory);

function _priceKey(bool isBuy, bool zeroForOne, uint256 amountIn, uint256 amountOut)
        internal
        pure
        returns (uint128);

event AsyncOrderCreated(
        PoolId indexed poolId,
        bytes32 indexed orderId,
        address indexed owner,
        bool zeroForOne,
        uint256 amountIn,
        uint256 amountOutMin,
        bytes32 salt
    );

event AsyncOrderPriceUpdated(
        PoolId indexed poolId, bytes32 indexed orderId, uint256 oldAmountOutMin, uint256 newAmountOutMin
    );

event AsyncOrderFilled(
        PoolId indexed poolId, bytes32 indexed orderId, address indexed filler, uint256 amountIn, uint256 amountOutMin
    );

event AsyncOrderCancelled(PoolId indexed poolId, bytes32 indexed orderId, address indexed owner, uint256 amountIn);

event OrderFeeAccrued(PoolId indexed poolId, bytes32 indexed orderId, Currency indexed currency, uint256 amount);

event PriorityFeeDonated(PoolId indexed poolId, bytes32 indexed orderId, address indexed maker, uint256 amount);

event PriorityFeeForfeited(PoolId indexed poolId, bytes32 indexed orderId, address indexed maker, uint256 amount);

error OrderAlreadyExists();

error OrderNotFound();

error NotOrderOwner();

error NotAuthorizedExecutor();

error ZeroAmount();

error PriorityFeeTooLarge();

error PriorityFeeTooSmall();

error BelowMinimumOrder();

error BelowMinimumAssetAmount();

struct OrderInfo {
        address owner;
        uint256 amountIn;
        uint256 amountOutMin;
        uint128 price;
        bool isBuy;
        bool zeroForOne;
        uint64 sequence;
        /// @dev Maker reprices so far; signed reprices commit to it (`OrderSignatures.hashUpdatePrice`).
        uint32 reprices;
        /// @dev The bid, escrowed as hook claims since the order was created.
        uint64 priorityFee;
        uint128 priorityKey;
        /// @dev Immutable settlement age; repricing only resets queue sequence.
        uint64 createdSequence;
    }

struct PriceLevel {
        uint32 orderCount;
        RadixPriceTree.Tree priorityOrders;
        mapping(uint128 priorityKey => bytes32 orderId) priorityOrderIds;
        mapping(uint32 nodeId => EligiblePrice.Ratio) exactBounds;
    }

struct MatchAmounts {
        uint256 assetAmount;
        uint256 quoteAmount;
    }

struct NewOrder {
        bytes32 id;
        address owner;
        uint256 amountIn;
        uint256 amountOutMin;
        bool isBuy;
        bool zeroForOne;
        uint256 priorityFee;
        PoolId poolId;
    }

struct State {
        IPoolManager poolManager;
        Currency numeraire;
        address feeVault;
        mapping(bytes32 orderId => OrderInfo) orders;
        mapping(address owner => mapping(address executor => bool)) isExecutor;
        /// @dev Pool tick before the first pool fill of the current backrun window, and that fill's block.
        int24 refTick;
        uint64 refBlock;
    }

struct Book {
        uint64 nextSequence;
        uint64 openOrderCount;
        /// @dev $0.10 in this pool's numeraire base units. Zero uses the six-decimal default.
        uint64 priorityFeeCap;
        TickBitmap.Tree bids;
        TickBitmap.Tree asks;
        mapping(uint128 price => PriceLevel) bidLevels;
        mapping(uint128 price => PriceLevel) askLevels;
        /// @dev Least order size in numeraire base units (0: none); see `checkMinimum`.
        uint256 minOrder;
        /// @dev Least asset amount an order may trade, from the asset's decimals and the hook's precision.
        uint256 minAssetAmount;
    }