feat: add priority tax reactor

.forge-snapshots/Base-DutchOrder-RevertInvalidNonce.snap

@@ -0,0 +1 @@
+26482

.forge-snapshots/Base-ExclusiveDutchOrder-RevertInvalidNonce.snap

@@ -0,0 +1 @@
+26649

.forge-snapshots/Base-LimitOrderReactor-RevertInvalidNonce.snap

@@ -0,0 +1 @@
+22699

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

@@ -0,0 +1 @@
+184811

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

@@ -0,0 +1 @@
+202966

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

@@ -0,0 +1 @@
+212779

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

@@ -0,0 +1 @@
+266488

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

@@ -0,0 +1 @@
+196492

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

@@ -0,0 +1 @@
+151201

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

@@ -0,0 +1 @@
+136764

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

@@ -0,0 +1 @@
+160512

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

@@ -0,0 +1 @@
+153386

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

@@ -0,0 +1 @@
+153195

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

@@ -0,0 +1 @@
+153191

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

@@ -0,0 +1 @@
+130608

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

@@ -0,0 +1 @@
+13727

.forge-snapshots/Base-V2DutchOrder-RevertInvalidNonce.snap

@@ -0,0 +1 @@
+33446

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/CosignerLib.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+/// @notice helper library for verifying cosignatures
+library CosignerLib {
+    /// @notice thrown when an order's cosignature does not match the expected cosigner
+    error InvalidCosignature();
+
+    /// @notice verify that a cosignature is valid for a given cosigner and data
+    /// @param cosigner the address of the cosigner
+    /// @param data the digest of (orderHash || cosignerData)
+    /// @param cosignature the cosigner's signature over the data
+    function verify(address cosigner, bytes32 data, bytes memory cosignature) internal pure {
+        (bytes32 r, bytes32 s) = abi.decode(cosignature, (bytes32, bytes32));
+        uint8 v = uint8(cosignature[64]);
+        address signer = ecrecover(data, v, r, s);
+        if (cosigner != signer || signer == address(0)) revert InvalidCosignature();
+    }
+}

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,158 @@
+// 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 PriorityCosignerData {
+    // the block at which the order can be executed (overrides auctionStartBlock)
+    uint256 auctionTargetBlock;
+}
+
+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 address which may cosign the order
+    address cosigner;
+    // the block at which the order can be executed
+    uint256 auctionStartBlock;
+    // the baseline priority fee for the order, above which additional taxes are applied
+    uint256 baselinePriorityFeeWei;
+    // 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;
+    // signed over by the cosigner
+    PriorityCosignerData cosignerData;
+    // signature from the cosigner over (orderHash || cosignerData)
+    bytes cosignature;
+}
+
+/// @notice helpers for handling priority order objects
+library PriorityOrderLib {
+    using OrderInfoLib for OrderInfo;
+
+    bytes internal constant PRIORITY_INPUT_TOKEN_TYPE =
+        "PriorityInput(address token,uint256 amount,uint256 mpsPerPriorityFeeWei)";
+
+    bytes32 internal constant PRIORITY_INPUT_TOKEN_TYPE_HASH = keccak256(PRIORITY_INPUT_TOKEN_TYPE);
+
+    bytes internal constant PRIORITY_OUTPUT_TOKEN_TYPE =
+        "PriorityOutput(address token,uint256 amount,uint256 mpsPerPriorityFeeWei,address recipient)";
+
+    bytes32 internal constant PRIORITY_OUTPUT_TOKEN_TYPE_HASH = keccak256(PRIORITY_OUTPUT_TOKEN_TYPE);
+
+    string internal constant TOKEN_PERMISSIONS_TYPE = "TokenPermissions(address token,uint256 amount)";
+
+    // EIP712 notes that nested structs should be ordered alphabetically.
+    // With our added PriorityOrder witness, the top level type becomes
+    // "PermitWitnessTransferFrom(TokenPermissions permitted,address spender,uint256 nonce,uint256 deadline,PriorityOrder witness)"
+    // Meaning we order the nested structs as follows:
+    // OrderInfo, PriorityInput, PriorityOrder, PriorityOutput
+    string internal constant PERMIT2_ORDER_TYPE = string(
+        abi.encodePacked(
+            "PriorityOrder witness)",
+            OrderInfoLib.ORDER_INFO_TYPE,
+            PriorityOrderLib.PRIORITY_INPUT_TOKEN_TYPE,
+            PriorityOrderLib.TOPLEVEL_PRIORITY_ORDER_TYPE,
+            PriorityOrderLib.PRIORITY_OUTPUT_TOKEN_TYPE,
+            TOKEN_PERMISSIONS_TYPE
+        )
+    );
+
+    bytes internal constant TOPLEVEL_PRIORITY_ORDER_TYPE = abi.encodePacked(
+        "PriorityOrder(",
+        "OrderInfo info,",
+        "address cosigner,",
+        "uint256 auctionStartBlock,",
+        "uint256 baselinePriorityFeeWei,",
+        "PriorityInput input,",
+        "PriorityOutput[] outputs)"
+    );
+
+    // EIP712 notes that nested structs should be ordered alphabetically:
+    // OrderInfo, PriorityInput, PriorityOutput
+    bytes internal constant ORDER_TYPE = abi.encodePacked(
+        PriorityOrderLib.TOPLEVEL_PRIORITY_ORDER_TYPE,
+        OrderInfoLib.ORDER_INFO_TYPE,
+        PriorityOrderLib.PRIORITY_INPUT_TOKEN_TYPE,
+        PriorityOrderLib.PRIORITY_OUTPUT_TOKEN_TYPE
+    );
+    bytes32 internal constant ORDER_TYPE_HASH = keccak256(ORDER_TYPE);
+
+    /// @notice returns the hash of an input token struct
+    function hash(PriorityInput memory input) private pure returns (bytes32) {
+        return
+            keccak256(abi.encode(PRIORITY_INPUT_TOKEN_TYPE_HASH, input.token, input.amount, input.mpsPerPriorityFeeWei));
+    }
+
+    /// @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.cosigner,
+                order.auctionStartBlock,
+                order.baselinePriorityFeeWei,
+                hash(order.input),
+                hash(order.outputs)
+            )
+        );
+    }
+
+    /// @notice get the digest of the cosigner data
+    /// @param order the priorityOrder
+    /// @param orderHash the hash of the order
+    function cosignerDigest(PriorityOrder memory order, bytes32 orderHash) internal pure returns (bytes32) {
+        return keccak256(abi.encodePacked(orderHash, abi.encode(order.cosignerData)));
+    }
+}