refactor: add BaseExecutor with built in permit

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

@@ -1 +1 @@
-197283
+197273

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

@@ -1 +1 @@
-207049
+207039

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

@@ -1 +1 @@
-260720
+260710

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

@@ -1 +1 @@
-190845
+190835

.forge-snapshots/SwapRouter02ExecutorExecute.snap

@@ -1 +1 @@
-262973
+250261

.forge-snapshots/SwapRouter02ExecutorExecuteAlreadyApproved.snap

@@ -1 +1 @@
-118092
+111715

.forge-snapshots/SwapRouter02ExecutorPermitAndExecute.snap

@@ -0,0 +1 @@
+305647

src/interfaces/IReactorCallback.sol

@@ -8,6 +8,7 @@ interface IReactorCallback {
     /// @notice Called by the reactor during the execution of an order
     /// @param resolvedOrders Has inputs and outputs
     /// @param callbackData The callbackData specified for an order execution
+    /// @dev Must only be called by the reactor
     /// @dev Must have approved each token and amount in outputs to the msg.sender
     function reactorCallback(ResolvedOrder[] memory resolvedOrders, bytes memory callbackData) external;
 }

src/sample-executors/BaseExecutor.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {Owned} from "solmate/src/auth/Owned.sol";
+import {SafeTransferLib} from "solmate/src/utils/SafeTransferLib.sol";
+import {ResolvedOrder, SignedOrder} from "../base/ReactorStructs.sol";
+import {IReactorCallback} from "../interfaces/IReactorCallback.sol";
+import {IReactor} from "../interfaces/IReactor.sol";
+import {Multicall} from "./Multicall.sol";
+
+abstract contract BaseExecutor is IReactorCallback, Multicall, Owned {
+    IReactor public immutable reactor;
+
+    /// @notice thrown if reactorCallback is called by an address other than the reactor
+    error MsgSenderNotReactor();
+    error NotImplemented();
+
+    constructor(IReactor _reactor, address _owner) Owned(_owner) {
+        reactor = _reactor;
+    }
+
+    modifier onlyReactor() {
+        if (msg.sender != address(reactor)) {
+            revert MsgSenderNotReactor();
+        }
+        _;
+    }
+
+    /// @inheritdoc IReactorCallback
+    /// @dev any overriding function MUST use the onlyReactor modifier
+    function reactorCallback(ResolvedOrder[] calldata, bytes calldata) external virtual onlyReactor {}
+
+    /// @notice execute a signed order
+    /// @dev consider restricting who can call this function
+    function execute(SignedOrder memory order, bytes memory callbackData) public payable virtual;
+
+    /// @notice execute a batch of signed orders
+    /// @dev consider restricting who can call this function
+    function executeBatch(SignedOrder[] memory orders, bytes memory callbackData) public payable virtual;
+
+    /// @notice required to receive native outputs
+    receive() external payable {}
+}

src/sample-executors/BaseExecutorWithPermit.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {ERC20} from "solmate/src/tokens/ERC20.sol";
+import {IReactor} from "../interfaces/IReactor.sol";
+import {BaseExecutor} from "./BaseExecutor.sol";
+import {Permit2Lib} from "permit2/src/libraries/Permit2Lib.sol";
+
+struct PermitData {
+    ERC20 token;
+    address owner;
+    address spender;
+    uint256 amount;
+    uint256 deadline;
+    uint8 v;
+    bytes32 r;
+    bytes32 s;
+}
+
+abstract contract BaseExecutorWithPermit is BaseExecutor {
+    constructor(IReactor _reactor, address _owner) BaseExecutor(_reactor, _owner) {}
+
+    /// @notice execute a signed ERC2612 permit
+    /// the transaction will revert if the permit cannot be executed
+    function permit(PermitData memory data) public {
+        Permit2Lib.permit2(data.token, data.owner, data.spender, data.amount, data.deadline, data.v, data.r, data.s);
+    }
+
+    /// @notice execute a batch of signed 2612-style permits
+    /// the transaction will revert if any of the permits cannot be executed
+    function permitBatch(PermitData[] memory data) external {
+        uint256 length = data.length;
+        for (uint256 i = 0; i < length;) {
+            permit(data[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+}

src/sample-executors/Multicall.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.16;
+
+/// @title Multicall
+/// @notice Code from https://github.com/Uniswap/v3-periphery/blob/main/contracts/base/Multicall.sol
+/// @notice Enables calling multiple methods in a single call to the contract
+abstract contract Multicall {
+    function multicall(bytes[] calldata data) public payable virtual returns (bytes[] memory results) {
+        results = new bytes[](data.length);
+        for (uint256 i = 0; i < data.length; i++) {
+            (bool success, bytes memory result) = address(this).delegatecall(data[i]);
+
+            if (!success) {
+                // handle custom errors
+                if (result.length == 4) {
+                    assembly {
+                        revert(add(result, 0x20), mload(result))
+                    }
+                }
+                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
+                if (result.length < 68) revert();
+                assembly {
+                    result := add(result, 0x04)
+                }
+                revert(abi.decode(result, (string)));
+            }
+
+            results[i] = result;
+        }
+    }
+}

src/sample-executors/SwapRouter02Executor.sol

@@ -10,21 +10,19 @@ import {IReactor} from "../interfaces/IReactor.sol";
 import {CurrencyLibrary} from "../lib/CurrencyLibrary.sol";
 import {ResolvedOrder, OutputToken, SignedOrder} from "../base/ReactorStructs.sol";
 import {ISwapRouter02} from "../external/ISwapRouter02.sol";
+import {BaseExecutorWithPermit} from "./BaseExecutorWithPermit.sol";
 
 /// @notice A fill contract that uses SwapRouter02 to execute trades
-contract SwapRouter02Executor is IReactorCallback, Owned {
+contract SwapRouter02Executor is BaseExecutorWithPermit {
     using SafeTransferLib for ERC20;
     using CurrencyLibrary for address;
 
     /// @notice thrown if reactorCallback is called with a non-whitelisted filler
     error CallerNotWhitelisted();
-    /// @notice thrown if reactorCallback is called by an address other than the reactor
-    error MsgSenderNotReactor();
 
-    ISwapRouter02 private immutable swapRouter02;
-    address private immutable whitelistedCaller;
-    IReactor private immutable reactor;
-    WETH private immutable weth;
+    ISwapRouter02 public immutable swapRouter02;
+    address public immutable whitelistedCaller;
+    WETH public immutable weth;
 
     modifier onlyWhitelistedCaller() {
         if (msg.sender != whitelistedCaller) {
@@ -33,38 +31,39 @@ contract SwapRouter02Executor is IReactorCallback, Owned {
         _;
     }
 
-    modifier onlyReactor() {
-        if (msg.sender != address(reactor)) {
-            revert MsgSenderNotReactor();
-        }
-        _;
-    }
-
     constructor(address _whitelistedCaller, IReactor _reactor, address _owner, ISwapRouter02 _swapRouter02)
-        Owned(_owner)
+        BaseExecutorWithPermit(_reactor, _owner)
     {
         whitelistedCaller = _whitelistedCaller;
-        reactor = _reactor;
         swapRouter02 = _swapRouter02;
         weth = WETH(payable(_swapRouter02.WETH9()));
     }
 
-    /// @notice assume that we already have all output tokens
-    function execute(SignedOrder calldata order, bytes calldata callbackData) external onlyWhitelistedCaller {
+    function execute(SignedOrder memory order, bytes memory callbackData)
+        public
+        payable
+        override
+        onlyWhitelistedCaller
+    {
         reactor.executeWithCallback(order, callbackData);
     }
 
-    /// @notice assume that we already have all output tokens
-    function executeBatch(SignedOrder[] calldata orders, bytes calldata callbackData) external onlyWhitelistedCaller {
+    function executeBatch(SignedOrder[] memory orders, bytes memory callbackData)
+        public
+        payable
+        override
+        onlyWhitelistedCaller
+    {
         reactor.executeBatchWithCallback(orders, callbackData);
     }
 
+    /// @inheritdoc IReactorCallback
     /// @notice fill UniswapX orders using SwapRouter02
     /// @param callbackData It has the below encoded:
     /// address[] memory tokensToApproveForSwapRouter02: Max approve these tokens to swapRouter02
     /// address[] memory tokensToApproveForReactor: Max approve these tokens to reactor
     /// bytes[] memory multicallData: Pass into swapRouter02.multicall()
-    function reactorCallback(ResolvedOrder[] calldata, bytes calldata callbackData) external onlyReactor {
+    function reactorCallback(ResolvedOrder[] calldata, bytes calldata callbackData) external override onlyReactor {
         (
             address[] memory tokensToApproveForSwapRouter02,
             address[] memory tokensToApproveForReactor,
@@ -93,7 +92,10 @@ contract SwapRouter02Executor is IReactorCallback, Owned {
     /// @notice This function can be used to convert ERC20s to ETH that remains in this contract
     /// @param tokensToApprove Max approve these tokens to swapRouter02
     /// @param multicallData Pass into swapRouter02.multicall()
-    function multicall(ERC20[] calldata tokensToApprove, bytes[] calldata multicallData) external onlyOwner {
+    function swapRouter02Multicall(ERC20[] calldata tokensToApprove, bytes[] calldata multicallData)
+        external
+        onlyOwner
+    {
         for (uint256 i = 0; i < tokensToApprove.length; i++) {
             tokensToApprove[i].safeApprove(address(swapRouter02), type(uint256).max);
         }
@@ -114,7 +116,4 @@ contract SwapRouter02Executor is IReactorCallback, Owned {
     function withdrawETH(address recipient) external onlyOwner {
         SafeTransferLib.safeTransferETH(recipient, address(this).balance);
     }
-
-    /// @notice Necessary for this contract to receive ETH when calling unwrapWETH()
-    receive() external payable {}
 }