feat: add priority tax reactor

.forge-snapshots/Base-PriorityOrderReactor-BaseExecuteSingleWithFee.snap

@@ -0,0 +1 @@
+180680

.forge-snapshots/Base-PriorityOrderReactor-ExecuteBatch.snap

@@ -0,0 +1 @@
+194596

.forge-snapshots/Base-PriorityOrderReactor-ExecuteBatchMultipleOutputs.snap

@@ -0,0 +1 @@
+204389

.forge-snapshots/Base-PriorityOrderReactor-ExecuteBatchMultipleOutputsDifferentTokens.snap

@@ -0,0 +1 @@
+258082

.forge-snapshots/Base-PriorityOrderReactor-ExecuteBatchNativeOutput.snap

@@ -0,0 +1 @@
+188122

.forge-snapshots/Base-PriorityOrderReactor-ExecuteSingle.snap

@@ -0,0 +1 @@
+147064

.forge-snapshots/Base-PriorityOrderReactor-ExecuteSingleNativeOutput.snap

@@ -0,0 +1 @@
+132627

.forge-snapshots/Base-PriorityOrderReactor-ExecuteSingleValidation.snap

@@ -0,0 +1 @@
+156380

foundry.toml

@@ -9,8 +9,8 @@ fs_permissions = [{ access = "read-write", path = ".forge-snapshots/"}]
 optimizer_runs = 1000000
 
 [profile.integration]
-no_match_path = ""
 match_path = "*/integration/*"
+no_match_path = "override/default/*"
 
 [profile.lite.optimizer_details.yulDetails]
 stackAllocation = true

src/lib/PriorityFeeLib.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {OutputToken, InputToken} from "../base/ReactorStructs.sol";
+import {PriorityOutput, PriorityInput} from "../lib/PriorityOrderLib.sol";
+import {FixedPointMathLib} from "solmate/src/utils/FixedPointMathLib.sol";
+
+/// @notice helpers for handling priority order objects
+library PriorityFeeLib {
+    using FixedPointMathLib for uint256;
+
+    /// @notice we denominate priority fees in terms of milli-bips, or one thousandth of a basis point
+    uint256 constant MPS = 1e7;
+
+    /// @notice returns a scaled input using the current priority fee and mpsPerPriorityFeeWei
+    /// @notice this value is bounded by 0 and the input amount
+    /// @notice the amount is scaled down to favor the swapper
+    /// @notice maxAmount is set to be the original amount and is used to rebuild the permit2 token permissions struct
+    /// @param input the input to scale
+    /// @param priorityFee the current priority fee in wei
+    /// @return a scaled input
+    function scale(PriorityInput memory input, uint256 priorityFee) internal pure returns (InputToken memory) {
+        uint256 scalingFactor = priorityFee * input.mpsPerPriorityFeeWei;
+        if (scalingFactor >= MPS) {
+            return InputToken({token: input.token, amount: 0, maxAmount: input.amount});
+        }
+        return InputToken({
+            token: input.token,
+            amount: input.amount.mulDivDown((MPS - scalingFactor), MPS),
+            maxAmount: input.amount
+        });
+    }
+
+    /// @notice returns a scaled output using the current priority fee and mpsPerPriorityFeeWei
+    /// @notice the amount is scaled up to favor the swapper
+    /// @param output the output to scale
+    /// @param priorityFee the current priority fee
+    /// @return a scaled output
+    function scale(PriorityOutput memory output, uint256 priorityFee) internal pure returns (OutputToken memory) {
+        return OutputToken({
+            token: output.token,
+            amount: output.amount.mulDivUp((MPS + (priorityFee * output.mpsPerPriorityFeeWei)), MPS),
+            recipient: output.recipient
+        });
+    }
+
+    /// @notice returns scaled outputs using the current priority fee and mpsPerPriorityFeeWei
+    function scale(PriorityOutput[] memory outputs, uint256 priorityFee)
+        internal
+        pure
+        returns (OutputToken[] memory result)
+    {
+        uint256 outputLength = outputs.length;
+        result = new OutputToken[](outputLength);
+        for (uint256 i = 0; i < outputLength; i++) {
+            result[i] = scale(outputs[i], priorityFee);
+        }
+    }
+}

src/lib/PriorityOrderLib.sol

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {OrderInfo, InputToken, OutputToken} from "../base/ReactorStructs.sol";
+import {OrderInfoLib} from "./OrderInfoLib.sol";
+import {ERC20} from "solmate/src/tokens/ERC20.sol";
+
+struct PriorityInput {
+    ERC20 token;
+    uint256 amount;
+    // the less amount of input to be received per wei of priority fee
+    uint256 mpsPerPriorityFeeWei;
+}
+
+struct PriorityOutput {
+    address token;
+    uint256 amount;
+    // the extra amount of output to be paid per wei of priority fee
+    uint256 mpsPerPriorityFeeWei;
+    address recipient;
+}
+
+/// @dev External struct used to specify priority orders
+struct PriorityOrder {
+    // generic order information
+    OrderInfo info;
+    // the block at which the order becomes active
+    uint256 startBlock;
+    // The tokens that the swapper will provide when settling the order
+    PriorityInput input;
+    // The tokens that must be received to satisfy the order
+    PriorityOutput[] outputs;
+}
+
+/// @notice helpers for handling priority order objects
+library PriorityOrderLib {
+    using OrderInfoLib for OrderInfo;
+
+    bytes private constant PRIORITY_OUTPUT_TOKEN_TYPE =
+        "PriorityOutput(address token,uint256 amount,uint256 mpsPerPriorityFeeWei,address recipient)";
+
+    bytes32 private constant PRIORITY_OUTPUT_TOKEN_TYPE_HASH = keccak256(PRIORITY_OUTPUT_TOKEN_TYPE);
+
+    bytes internal constant ORDER_TYPE = abi.encodePacked(
+        "PriorityOrder(",
+        "OrderInfo info,",
+        "uint256 startBlock,",
+        "address inputToken,",
+        "uint256 inputAmount,",
+        "uint256 inputMpsPerPriorityFeeWei,",
+        "PriorityOutput[] outputs)",
+        OrderInfoLib.ORDER_INFO_TYPE,
+        PRIORITY_OUTPUT_TOKEN_TYPE
+    );
+    bytes32 internal constant ORDER_TYPE_HASH = keccak256(ORDER_TYPE);
+
+    string private constant TOKEN_PERMISSIONS_TYPE = "TokenPermissions(address token,uint256 amount)";
+    string internal constant PERMIT2_ORDER_TYPE =
+        string(abi.encodePacked("PriorityOrder witness)", ORDER_TYPE, TOKEN_PERMISSIONS_TYPE));
+
+    /// @notice returns the hash of an output token struct
+    function hash(PriorityOutput memory output) private pure returns (bytes32) {
+        return keccak256(
+            abi.encode(
+                PRIORITY_OUTPUT_TOKEN_TYPE_HASH,
+                output.token,
+                output.amount,
+                output.mpsPerPriorityFeeWei,
+                output.recipient
+            )
+        );
+    }
+
+    /// @notice returns the hash of an output token struct
+    function hash(PriorityOutput[] memory outputs) private pure returns (bytes32) {
+        unchecked {
+            bytes memory packedHashes = new bytes(32 * outputs.length);
+
+            for (uint256 i = 0; i < outputs.length; i++) {
+                bytes32 outputHash = hash(outputs[i]);
+                assembly {
+                    mstore(add(add(packedHashes, 0x20), mul(i, 0x20)), outputHash)
+                }
+            }
+
+            return keccak256(packedHashes);
+        }
+    }
+
+    /// @notice hash the given order
+    /// @param order the order to hash
+    /// @return the eip-712 order hash
+    function hash(PriorityOrder memory order) internal pure returns (bytes32) {
+        return keccak256(
+            abi.encode(
+                ORDER_TYPE_HASH,
+                order.info.hash(),
+                order.startBlock,
+                order.input.token,
+                order.input.amount,
+                order.input.mpsPerPriorityFeeWei,
+                hash(order.outputs)
+            )
+        );
+    }
+}

src/reactors/PriorityOrderReactor.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {BaseReactor} from "./BaseReactor.sol";
+import {Permit2Lib} from "../lib/Permit2Lib.sol";
+import {PriorityOrderLib, PriorityOrder, PriorityInput, PriorityOutput} from "../lib/PriorityOrderLib.sol";
+import {PriorityFeeLib} from "../lib/PriorityFeeLib.sol";
+import {SignedOrder, ResolvedOrder} from "../base/ReactorStructs.sol";
+import {IPermit2} from "permit2/src/interfaces/IPermit2.sol";
+
+/// @notice Reactor for priority orders
+/// @dev only supported on chains which use priority fee transaction ordering
+contract PriorityOrderReactor is BaseReactor {
+    using Permit2Lib for ResolvedOrder;
+    using PriorityOrderLib for PriorityOrder;
+    using PriorityFeeLib for PriorityInput;
+    using PriorityFeeLib for PriorityOutput[];
+
+    error InvalidDeadline();
+    error OrderNotFillable();
+    error InputOutputScaling();
+
+    constructor(IPermit2 _permit2, address _protocolFeeOwner) BaseReactor(_permit2, _protocolFeeOwner) {}
+
+    /// @inheritdoc BaseReactor
+    /// @notice a tx's priority fee must be equal to the difference between the tx gas price and the block's base fee
+    ///         this may not be the case on all chains
+    function _resolve(SignedOrder calldata signedOrder)
+        internal
+        view
+        override
+        returns (ResolvedOrder memory resolvedOrder)
+    {
+        PriorityOrder memory priorityOrder = abi.decode(signedOrder.order, (PriorityOrder));
+        _validateOrder(priorityOrder);
+
+        uint256 priorityFee = tx.gasprice - block.basefee;
+        resolvedOrder = ResolvedOrder({
+            info: priorityOrder.info,
+            input: priorityOrder.input.scale(priorityFee),
+            outputs: priorityOrder.outputs.scale(priorityFee),
+            sig: signedOrder.sig,
+            hash: priorityOrder.hash()
+        });
+    }
+
+    /// @inheritdoc BaseReactor
+    function _transferInputTokens(ResolvedOrder memory order, address to) internal override {
+        permit2.permitWitnessTransferFrom(
+            order.toPermit(),
+            order.transferDetails(to),
+            order.info.swapper,
+            order.hash,
+            PriorityOrderLib.PERMIT2_ORDER_TYPE,
+            order.sig
+        );
+    }
+
+    /// @notice validate the priority order fields
+    /// - deadline must be in the future
+    /// - startBlock must be in the past
+    /// - if input scales with priority fee, outputs must not scale
+    /// @dev Throws if the order is invalid
+    function _validateOrder(PriorityOrder memory order) internal view {
+        if (order.info.deadline < block.timestamp) {
+            revert InvalidDeadline();
+        }
+
+        if (order.startBlock > block.number) {
+            revert OrderNotFillable();
+        }
+
+        if (order.input.mpsPerPriorityFeeWei > 0) {
+            for (uint256 i = 0; i < order.outputs.length; i++) {
+                if (order.outputs[i].mpsPerPriorityFeeWei > 0) {
+                    revert InputOutputScaling();
+                }
+            }
+        }
+    }
+}