refactor: add BaseExecutor with built in permit

.forge-snapshots/SwapRouter02ExecutorExecute.snap

@@ -1 +1 @@
-262973
+248358

.forge-snapshots/SwapRouter02ExecutorExecuteAlreadyApproved.snap

@@ -1 +1 @@
-118092
+109807

.forge-snapshots/SwapRouter02ExecutorPermitAndExecute.snap

@@ -0,0 +1 @@
+302552

src/sample-executors/BaseExecutor.sol

@@ -0,0 +1,110 @@
+// 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";
+
+library Commands {
+    bytes1 internal constant COMMAND_TYPE_MASK = 0x0f;
+
+    uint256 constant EXECUTE = 0x00;
+    uint256 constant EXECUTE_BATCH = 0x01;
+    uint256 constant PERMIT = 0x02;
+    uint256 constant PERMIT_BATCH = 0x03;
+    // 0x04 - 0x0f are reserved for future use
+}
+
+struct PermitData {
+    address token;
+    bytes data;
+}
+
+abstract contract BaseExecutor is IReactorCallback, Owned {
+    /// @notice Thrown when attempting to execute commands and an incorrect number of inputs are provided
+    error LengthMismatch();
+    error InvalidCommandType(uint256 commandType);
+
+    IReactor public immutable reactor;
+
+    constructor(IReactor _reactor, address _owner) Owned(_owner) {
+        reactor = _reactor;
+    }
+
+    function reactorCallback(ResolvedOrder[] calldata, bytes calldata callbackData) external virtual;
+
+    function _restrictCall() internal virtual {}
+
+    function dispatch(bytes calldata commands, bytes[] calldata inputs) external payable {
+        _restrictCall();
+        uint256 numCommands = commands.length;
+        if (inputs.length != numCommands) revert LengthMismatch();
+
+        // loop through all given commands, execute them and pass along outputs as defined
+        for (uint256 commandIndex = 0; commandIndex < numCommands;) {
+            uint256 command = uint8(commands[commandIndex] & Commands.COMMAND_TYPE_MASK);
+            bytes calldata input = inputs[commandIndex];
+
+            if (command == Commands.EXECUTE) {
+                SignedOrder memory order;
+                bytes memory callbackData;
+
+                (order.order, order.sig, callbackData) = abi.decode(input, (bytes, bytes, bytes));
+                _execute(order, callbackData);
+            } else if (command == Commands.EXECUTE_BATCH) {
+                (bytes[] memory orderInputs, bytes memory callbackData) = abi.decode(input, (bytes[], bytes));
+                SignedOrder[] memory orders = new SignedOrder[](orderInputs.length);
+                for (uint256 i = 0; i < orderInputs.length; i++) {
+                    SignedOrder memory order;
+                    (order.order, order.sig) = abi.decode(orderInputs[i], (bytes, bytes));
+                    orders[i] = order;
+                }
+
+                _executeBatch(orders, callbackData);
+            } else if (command == Commands.PERMIT) {
+                PermitData memory permit = abi.decode(input, (PermitData));
+                _permit(permit);
+            } else if (command == Commands.PERMIT_BATCH) {
+                PermitData[] memory permits = abi.decode(input, (PermitData[]));
+                _permitBatch(permits);
+            } else {
+                revert InvalidCommandType(command);
+            }
+            unchecked {
+                commandIndex++;
+            }
+        }
+    }
+
+    function _execute(SignedOrder memory order, bytes memory callbackData) internal {
+        reactor.executeWithCallback(order, callbackData);
+    }
+
+    function _executeBatch(SignedOrder[] memory orders, bytes memory callbackData) internal {
+        reactor.executeBatchWithCallback(orders, callbackData);
+    }
+
+    /// @notice execute a signed 2612-style permit
+    /// the transaction will revert if the permit cannot be executed
+    /// must be called before the call to the reactor
+    function _permit(PermitData memory permit) internal {
+        (address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) =
+            abi.decode(permit.data, (address, address, uint256, uint256, uint8, bytes32, bytes32));
+        ERC20(permit.token).permit(owner, spender, value, deadline, v, r, s);
+    }
+
+    function _permitBatch(PermitData[] memory permits) internal {
+        for (uint256 i = 0; i < permits.length;) {
+            _permit(permits[i]);
+            unchecked {
+                i++;
+            }
+        }
+    }
+
+    receive() external payable {}
+}

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,21 @@ 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);
-    }
-
-    /// @notice assume that we already have all output tokens
-    function executeBatch(SignedOrder[] calldata orders, bytes calldata callbackData) external onlyWhitelistedCaller {
-        reactor.executeBatchWithCallback(orders, callbackData);
-    }
+    function _restrictCall() internal override onlyWhitelistedCaller {}
 
     /// @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,
@@ -114,7 +105,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 {}
 }