feat: make fee collector open and competitive

New fee collector implementation where anyone can make any calls from
the collector in return for a specific amount of the fee token.
Searchers can then compete to execute based on the current balance of
tokens and the best route

Author: marktoda

src/FeeCollector.sol

@@ -5,62 +5,52 @@ import {Owned} from "solmate/auth/Owned.sol";
 import {ERC20} from "solmate/tokens/ERC20.sol";
 import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
 import {IFeeCollector} from "./interfaces/IFeeCollector.sol";
-import {IPermit2} from "./external/IPermit2.sol";
 
 /// @notice The collector of protocol fees that will be used to swap and send to a fee recipient address.
 contract FeeCollector is Owned, IFeeCollector {
     using SafeTransferLib for ERC20;
 
-    error UniversalRouterCallFailed();
+    error CallFailed();
 
-    address private immutable universalRouter;
+    struct Call {
+        address to;
+        bytes data;
+    }
 
+    address public feeRecipient;
+    uin256 public feeTokenAmount;
     ERC20 private immutable feeToken;
-    IPermit2 private immutable permit2;
-
-    uint256 private constant MAX_APPROVAL_AMOUNT = type(uint256).max;
-    uint160 private constant MAX_PERMIT2_APPROVAL_AMOUNT = type(uint160).max;
-    uint48 private constant MAX_PERMIT2_DEADLINE = type(uint48).max;
 
-    constructor(address _owner, address _universalRouter, address _permit2, address _feeToken) Owned(_owner) {
-        universalRouter = _universalRouter;
+    constructor(address _owner, address _feeToken, uint256 _feeTokenAmount) Owned(_owner) {
         feeToken = ERC20(_feeToken);
-        permit2 = IPermit2(_permit2);
-    }
-
-    /// @inheritdoc IFeeCollector
-    function swapBalance(bytes calldata swapData, uint256 nativeValue) external onlyOwner {
-        _execute(swapData, nativeValue);
+        feeTokenAmount = _feeTokenAmount;
     }
 
-    /// @inheritdoc IFeeCollector
-    function swapBalance(bytes calldata swapData, uint256 nativeValue, ERC20[] calldata tokensToApprove)
-        external
-        onlyOwner
-    {
-        unchecked {
-            for (uint256 i = 0; i < tokensToApprove.length; i++) {
-                tokensToApprove[i].safeApprove(address(permit2), MAX_APPROVAL_AMOUNT);
-                permit2.approve(
-                    address(tokensToApprove[i]), universalRouter, MAX_PERMIT2_APPROVAL_AMOUNT, MAX_PERMIT2_DEADLINE
-                );
+    /// @notice allow anyone to make any arbitrary calls from this address
+    /// @dev as long as they pay `feeTokenAmount` to the `feeRecipient`
+    ///     this creates a competitive auction as the balances of this contract increase
+    ///     to find the optimal path for the swap
+    function swapBalances(Call[] calldata calls) external {
+        for (uint256 i = 0; i < calls.length; i++) {
+            (bool success, ) = calls[i].to.call(calls[i].data);
+            if (!success) {
+                revert CallFailed();
             }
         }
 
-        _execute(swapData, nativeValue);
+        feeToken.safeTransferFrom(msg.sender, feeRecipient, feeTokenAmount);
+    }
+
+    function setFeeRecipient(address _feeRecipient) external onlyOwner {
+        feeRecipient = _feeRecipient;
     }
 
-    /// @notice Helper function to call UniversalRouter.
-    /// @param swapData The bytes call data to be forwarded to UniversalRouter.
-    /// @param nativeValue The amount of native currency to send to UniversalRouter.
-    function _execute(bytes calldata swapData, uint256 nativeValue) internal {
-        (bool success,) = universalRouter.call{value: nativeValue}(swapData);
-        if (!success) revert UniversalRouterCallFailed();
+    function setFeeToken(uint256 _feeTokenAmount) external onlyOwner {
+        feeTokenAmount = _feeTokenAmount;
     }
 
-    /// @inheritdoc IFeeCollector
-    function withdrawFeeToken(address feeRecipient, uint256 amount) external onlyOwner {
-        feeToken.safeTransfer(feeRecipient, amount);
+    function setFeeTokenAmount(uint256 _feeTokenAmount) external onlyOwner {
+        feeTokenAmount = _feeTokenAmount;
     }
 
     receive() external payable {}