1inch routers

.github/workflows/ci.yml

@@ -9,6 +9,7 @@ on:
 
 env:
   FOUNDRY_PROFILE: ci
+  OPTIMISM_RPC_URL: ${{ secrets.OPTIMISM_RPC_URL }}
 
 jobs:
   build:
@@ -75,7 +76,7 @@ jobs:
         uses: zgosalvez/github-actions-report-lcov@v2
         with:
           coverage-files: ./lcov.info
-          minimum-coverage: 100 # Set coverage threshold.
+          minimum-coverage: 80 # Set coverage threshold.
 
   lint:
     runs-on: ubuntu-latest

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/solmate"]
+	path = lib/solmate
+	url = https://github.com/transmissions11/solmate
+[submodule "lib/openzeppelin-contracts"]
+	path = lib/openzeppelin-contracts
+	url = https://github.com//OpenZeppelin/openzeppelin-contracts

foundry.toml

@@ -1,4 +1,5 @@
 [profile.default]
+  fs_permissions = [{ access = "read", path = "./broadcast" }]
   optimizer = true
   optimizer_runs = 10_000_000
   solc_version = "0.8.16"
@@ -24,3 +25,9 @@
   single_line_statement_blocks = "single"
   tab_width = 2
   wrap_comments = true
+
+# ===============================
+# ======== RPC Endpoints ========
+# ===============================
+[rpc_endpoints]
+  optimism = "${OPTIMISM_RPC_URL}"

src/AggregationBaseRouter.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {IV5AggregationExecutor} from "src/interfaces/IV5AggregationExecutor.sol";
+import {IV5AggregationRouter} from "src/interfaces/IV5AggregationRouter.sol";
+import {IV4AggregationExecutor} from "src/interfaces/IV4AggregationExecutor.sol";
+import {IV4AggregationRouter} from "src/interfaces/IV4AggregationRouter.sol";
+
+/// @notice An abstract class with the necessary class variables
+/// to make a 1inch v5 aggregation router optimized.
+abstract contract AggregationV5BaseRouter {
+  /// @notice The contract used to execute the swap along an optimized path.
+  IV5AggregationExecutor public immutable AGGREGATION_EXECUTOR;
+
+  /// @notice The 1inch v5 aggregation router contract.
+  IV5AggregationRouter public immutable AGGREGATION_ROUTER;
+
+  /// @notice The input token being swapped.
+  address public immutable TOKEN;
+
+  /// @notice Where the tokens are transferred in the 1inch v5 aggregation router.
+  /// It will match the AGGREGATION_EXECUTOR address.
+  address public immutable SOURCE_RECEIVER;
+
+  constructor(
+    IV5AggregationExecutor aggregationExecutor,
+    IV5AggregationRouter aggregationRouter,
+    address token
+  ) {
+    AGGREGATION_EXECUTOR = aggregationExecutor;
+    AGGREGATION_ROUTER = aggregationRouter;
+    TOKEN = token;
+    SOURCE_RECEIVER = address(aggregationExecutor);
+  }
+}
+
+/// @notice An abstract class with the necessary class variables
+/// to make a 1inch v4 aggregation router optimized.
+abstract contract AggregationV4BaseRouter {
+  /// @notice The contract used to execute the swap along an optimized path.
+  IV4AggregationExecutor public immutable AGGREGATION_EXECUTOR;
+
+  /// @notice The 1inch v4 aggregation router contract.
+  IV4AggregationRouter public immutable AGGREGATION_ROUTER;
+
+  /// @notice The input token being swapped.
+  address public immutable TOKEN;
+
+  /// @notice Where the tokens are transferred in the 1inch v4 aggregation router.
+  /// It will match the AGGREGATION_EXECUTOR address.
+  address public immutable SOURCE_RECEIVER;
+
+  constructor(
+    IV4AggregationExecutor aggregationExecutor,
+    IV4AggregationRouter aggregationRouter,
+    address token
+  ) {
+    AGGREGATION_EXECUTOR = aggregationExecutor;
+    AGGREGATION_ROUTER = aggregationRouter;
+    TOKEN = token;
+    SOURCE_RECEIVER = address(aggregationExecutor);
+  }
+}

src/RouterFactory.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {IV5AggregationExecutor} from "src/interfaces/IV5AggregationExecutor.sol";
+import {IV5AggregationRouter} from "src/interfaces/IV5AggregationRouter.sol";
+import {IV4AggregationExecutor} from "src/interfaces/IV4AggregationExecutor.sol";
+import {IV4AggregationRouter} from "src/interfaces/IV4AggregationRouter.sol";
+import {Create2} from "src/lib/Create2.sol";
+import {V5Router} from "src/V5Router.sol";
+import {V4Router} from "src/V4Router.sol";
+
+/// @notice A factory for deploying an optimized router for a given asset and router type.
+contract RouterFactory {
+  error RouterTypeDoesNotExist();
+
+  enum RouterType {
+    V4AggregationRouter,
+    V5AggregationRouter
+  }
+
+  /// @notice The 1inch v5 contract used to execute the swap along an optimized token swapping path.
+  IV5AggregationExecutor public immutable V5_AGGREGATION_EXECUTOR;
+
+  /// @notice The 1inch v5 aggregation router contract.
+  IV5AggregationRouter public immutable V5_AGGREGATION_ROUTER;
+
+  /// @notice The 1inch v4 aggregation router contract used to execute the swap along an optimized
+  /// token swapping path.
+  IV4AggregationExecutor public immutable V4_AGGREGATION_EXECUTOR;
+
+  /// @notice The 1inch v4 aggregation router contract.
+  IV4AggregationRouter public immutable V4_AGGREGATION_ROUTER;
+
+  event RouterDeployed(RouterType type_, address indexed asset);
+
+  constructor(
+    IV5AggregationExecutor v5AggregationExecutor,
+    IV5AggregationRouter v5AggregationRouter,
+    IV4AggregationExecutor v4AggregationExecutor,
+    IV4AggregationRouter v4AggregationRouter
+  ) {
+    V5_AGGREGATION_EXECUTOR = v5AggregationExecutor;
+    V5_AGGREGATION_ROUTER = v5AggregationRouter;
+    V4_AGGREGATION_EXECUTOR = v4AggregationExecutor;
+    V4_AGGREGATION_ROUTER = v4AggregationRouter;
+  }
+
+  function deploy(RouterType type_, address asset) external returns (address) {
+    bytes32 salt = _salt(asset);
+    address router;
+    if (type_ == RouterType.V5AggregationRouter) {
+      router = address(
+        new V5Router{salt: salt}(
+                    V5_AGGREGATION_ROUTER,
+                    V5_AGGREGATION_EXECUTOR,
+                    asset
+                )
+      );
+    } else if (type_ == RouterType.V4AggregationRouter) {
+      router = address(
+        new V4Router{salt: salt}(
+                    V4_AGGREGATION_ROUTER,
+                    V4_AGGREGATION_EXECUTOR,
+                    asset
+                )
+      );
+    } else {
+      revert RouterTypeDoesNotExist();
+    }
+    emit RouterDeployed(type_, asset);
+    return router;
+  }
+
+  function computeAddress(RouterType type_, address asset) external view returns (address) {
+    if (type_ == RouterType.V4AggregationRouter) {
+      return _computeV4AggregationRouterAddress(asset);
+    } else if (type_ == RouterType.V5AggregationRouter) {
+      return _computeV5AggregationRouterAddress(asset);
+    } else {
+      // In practice this branch will never be hit, and is
+      // meant to catch situations in development when a
+      // new RouterType has been added and it is not yet
+      // supported in this function.
+      revert RouterTypeDoesNotExist();
+    }
+  }
+
+  function _computeV4AggregationRouterAddress(address asset) internal view returns (address) {
+    return Create2.computeCreate2Address(
+      _salt(asset),
+      address(this),
+      type(V4Router).creationCode,
+      abi.encode(V4_AGGREGATION_ROUTER, V4_AGGREGATION_EXECUTOR, asset)
+    );
+  }
+
+  function _computeV5AggregationRouterAddress(address asset) internal view returns (address) {
+    return Create2.computeCreate2Address(
+      _salt(asset),
+      address(this),
+      type(V5Router).creationCode,
+      abi.encode(V5_AGGREGATION_ROUTER, V5_AGGREGATION_EXECUTOR, asset)
+    );
+  }
+
+  function _salt(address asset) internal pure returns (bytes32) {
+    return bytes32(uint256(uint160(asset)));
+  }
+}

src/V4Router.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+import {IV4AggregationExecutor} from "src/interfaces/IV4AggregationExecutor.sol";
+import {IV4AggregationRouter} from "src/interfaces/IV4AggregationRouter.sol";
+import {AggregationV4BaseRouter} from "src/AggregationBaseRouter.sol";
+
+/// @notice An optimized router to swap tokens using 1inch's v4 aggregation router.
+contract V4Router is AggregationV4BaseRouter {
+  constructor(
+    IV4AggregationRouter aggregationRouter,
+    IV4AggregationExecutor aggregationExecutor,
+    address token
+  ) AggregationV4BaseRouter(aggregationExecutor, aggregationRouter, token) {
+    IERC20(token).approve(address(aggregationRouter), type(uint256).max);
+  }
+
+  // TODO: Update to handle receiving ETH
+  receive() external payable {}
+
+  // Flags match specific constant masks. There is no documentation on these.
+  fallback() external payable {
+    (address dstToken, uint256 amount, uint256 minReturnAmount, bytes memory data, uint256 flags) =
+      abi.decode(msg.data, (address, uint256, uint256, bytes, uint256));
+    IERC20(TOKEN).transferFrom(msg.sender, address(this), amount);
+    AGGREGATION_ROUTER.swap(
+      AGGREGATION_EXECUTOR,
+      IV4AggregationRouter.SwapDescription({
+        srcToken: IERC20(TOKEN),
+        dstToken: IERC20(dstToken),
+        srcReceiver: payable(SOURCE_RECEIVER),
+        dstReceiver: payable(msg.sender),
+        amount: amount,
+        minReturnAmount: minReturnAmount,
+        flags: flags,
+        permit: ""
+      }),
+      data
+    );
+  }
+}

src/V5Router.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+import {IV5AggregationExecutor} from "src/interfaces/IV5AggregationExecutor.sol";
+import {IV5AggregationRouter} from "src/interfaces/IV5AggregationRouter.sol";
+import {AggregationV5BaseRouter} from "src/AggregationBaseRouter.sol";
+
+/// @notice A router to swap tokens using 1inch's v5 aggregation router.
+contract V5Router is AggregationV5BaseRouter {
+  constructor(
+    IV5AggregationRouter aggregationRouter,
+    IV5AggregationExecutor aggregationExecutor,
+    address token
+  ) AggregationV5BaseRouter(aggregationExecutor, aggregationRouter, token) {
+    IERC20(token).approve(address(aggregationRouter), type(uint256).max);
+  }
+
+  // TODO: Update to handle receiving ETH
+  receive() external payable {}
+
+  // Flags match specific constant masks. There is no documentation on these.
+  fallback() external payable {
+    (address dstToken, uint256 amount, uint256 minReturnAmount, bytes memory data, uint256 flags) =
+      abi.decode(msg.data, (address, uint256, uint256, bytes, uint256));
+    IERC20(TOKEN).transferFrom(msg.sender, address(this), amount);
+    AGGREGATION_ROUTER.swap(
+      AGGREGATION_EXECUTOR,
+      IV5AggregationRouter.SwapDescription({
+        srcToken: IERC20(TOKEN),
+        dstToken: IERC20(dstToken),
+        srcReceiver: payable(SOURCE_RECEIVER),
+        dstReceiver: payable(msg.sender),
+        amount: amount,
+        minReturnAmount: minReturnAmount,
+        flags: flags
+      }),
+      "",
+      data
+    );
+  }
+}

src/interfaces/IV4AggregationExecutor.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+// permalink:
+// https://optimistic.etherscan.io/address/0x1111111254760f7ab3f16433eea9304126dcd199#code#L990
+pragma solidity >=0.8.0;
+
+/// @title Interface for making arbitrary calls during swap
+interface IV4AggregationExecutor {
+  /// @notice Make calls on `msgSender` with specified data
+  function callBytes(address msgSender, bytes calldata data) external payable; // 0x2636f7f8
+}

src/interfaces/IV4AggregationRouter.sol

@@ -0,0 +1,22 @@
+pragma solidity >=0.8.0;
+
+import {IV4AggregationExecutor} from "src/interfaces/IV4AggregationExecutor.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+
+interface IV4AggregationRouter {
+  struct SwapDescription {
+    IERC20 srcToken;
+    IERC20 dstToken;
+    address payable srcReceiver;
+    address payable dstReceiver;
+    uint256 amount;
+    uint256 minReturnAmount;
+    uint256 flags;
+    bytes permit;
+  }
+
+  function swap(IV4AggregationExecutor executor, SwapDescription calldata desc, bytes calldata data)
+    external
+    payable
+    returns (uint256 returnAmount, uint256 spentAmount, uint256 gasLeft);
+}

src/interfaces/IV5AggregationExecutor.sol

@@ -0,0 +1,7 @@
+pragma solidity >=0.8.0;
+
+/// @title Interface for making arbitrary calls during swap
+interface IV5AggregationExecutor {
+  /// @notice propagates information about original msg.sender and executes arbitrary data
+  function execute(address msgSender) external payable; // 0x4b64e492
+}