refactor: add BaseExecutor with built in permit

.forge-snapshots/SwapRouter02ExecutorExecute.snap

@@ -1 +1 @@
-262973
+250368

.forge-snapshots/SwapRouter02ExecutorExecuteAlreadyApproved.snap

@@ -1 +1 @@
-118092
+111822

.forge-snapshots/SwapRouter02ExecutorPermitAndExecute.snap

@@ -0,0 +1 @@
+305754

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,64 @@
+// 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 {ERC20} from "solmate/src/tokens/ERC20.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";
+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 BaseExecutor is IReactorCallback, Multicall, Owned {
+    IReactor public immutable reactor;
+
+    constructor(IReactor _reactor, address _owner) Owned(_owner) {
+        reactor = _reactor;
+    }
+
+    /// @inheritdoc IReactorCallback
+    function reactorCallback(ResolvedOrder[] calldata, bytes calldata callbackData) external virtual;
+
+    /// @notice execute a signed order
+    function execute(SignedOrder memory order, bytes memory callbackData) public payable virtual {
+        reactor.executeWithCallback(order, callbackData);
+    }
+
+    /// @notice execute a batch of signed orders
+    function executeBatch(SignedOrder[] memory orders, bytes memory callbackData) public payable virtual {
+        reactor.executeBatchWithCallback(orders, callbackData);
+    }
+
+    /// @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++;
+            }
+        }
+    }
+
+    receive() external payable {}
+}

src/sample-executors/Multicall.sol

@@ -0,0 +1,25 @@
+// 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) {
+                // 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,9 +10,10 @@ 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 {BaseExecutor} from "./BaseExecutor.sol";
 
 /// @notice A fill contract that uses SwapRouter02 to execute trades
-contract SwapRouter02Executor is IReactorCallback, Owned {
+contract SwapRouter02Executor is BaseExecutor {
     using SafeTransferLib for ERC20;
     using CurrencyLibrary for address;
 
@@ -21,10 +22,9 @@ contract SwapRouter02Executor is IReactorCallback, Owned {
     /// @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) {
@@ -41,30 +41,41 @@ contract SwapRouter02Executor is IReactorCallback, Owned {
     }
 
     constructor(address _whitelistedCaller, IReactor _reactor, address _owner, ISwapRouter02 _swapRouter02)
-        Owned(_owner)
+        BaseExecutor(_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 {
-        reactor.executeWithCallback(order, callbackData);
+    function multicall(bytes[] calldata data) public payable override onlyWhitelistedCaller returns (bytes[] memory) {
+        return super.multicall(data);
     }
 
-    /// @notice assume that we already have all output tokens
-    function executeBatch(SignedOrder[] calldata orders, bytes calldata callbackData) external onlyWhitelistedCaller {
-        reactor.executeBatchWithCallback(orders, callbackData);
+    function execute(SignedOrder memory order, bytes memory callbackData)
+        public
+        payable
+        override
+        onlyWhitelistedCaller
+    {
+        return super.execute(order, callbackData);
+    }
+
+    function executeBatch(SignedOrder[] memory orders, bytes memory callbackData)
+        public
+        payable
+        override
+        onlyWhitelistedCaller
+    {
+        return super.executeBatch(orders, callbackData);
     }
 
     /// @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 +104,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 +128,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 {}
 }