feat(UniswapV3ExchangeAdapterV2): Add UniswapV3ExchangeAdapterV2 exch…

…ange adapter (SetProtocol#240)

* Add uniswapV3ExchangeAdapterV2 contract

* Fix compilation bug

* Add unit tests

* Fix exactOutput bug; Make toBool public and add unit tests for it

* Add integration tests with TradeModule

* Fix coverage: Remove .only from tests

* Improve javadocs and comments; Add suggested changes

contracts/protocol/integration/exchange/UniswapV3ExchangeAdapterV2.sol

@@ -0,0 +1,188 @@
+/*
+ Copyright 2022 Set Labs Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ SPDX-License-Identifier: Apache License, Version 2.0
+*/
+
+pragma solidity 0.6.10;
+pragma experimental "ABIEncoderV2";
+
+import { BytesLib } from "../../../../external/contracts/uniswap/v3/lib/BytesLib.sol";
+import { ISwapRouter } from "../../../interfaces/external/ISwapRouter.sol";
+
+/**
+ * @title UniswapV3ExchangeAdapterV2
+ * @author Set Protocol
+ *
+ * Exchange adapter for Uniswap V3 SwapRouter that encodes trade data. Supports multi-hop trades.
+ *
+ * CHANGE LOG:
+ * - Generalized ability to choose whether to swap an exact amount of source token for a min amount of
+ * receive token or swap a max amount of source token for an exact amount of receive token.
+ */
+contract UniswapV3ExchangeAdapterV2 {
+
+ using BytesLib for bytes;
+
+ /* ============ State Variables ============ */
+
+ // Address of Uniswap V3 SwapRouter contract
+ address public immutable swapRouter;
+
+ /* ============ Constructor ============ */
+
+ /**
+ * Set state variables
+ *
+ * @param _swapRouter Address of Uniswap V3 SwapRouter
+ */
+ constructor(address _swapRouter) public {
+ swapRouter = _swapRouter;
+ }
+
+ /* ============ External Getter Functions ============ */
+
+ /**
+ * Return calldata for Uniswap V3 SwapRouter
+ *
+ * @param _sourceToken Address of source token to be sold
+ * @param _destinationToken Address of destination token to buy
+ * @param _destinationAddress Address that assets should be transferred to
+ * @param _sourceQuantity Fixed/Max amount of source token to sell
+ * @param _destinationQuantity Min/Fixed amount of destination token to buy
+ * @param _data Bytes containing trade path and bool to determine function string.
+ * Equals the output of the generateDataParam function
+ * NOTE: Path for `exactOutput` swaps are reversed
+ *
+ * @return address Target contract address
+ * @return uint256 Call value
+ * @return bytes Trade calldata
+ */
+ function getTradeCalldata(
+ address _sourceToken,
+ address _destinationToken,
+ address _destinationAddress,
+ uint256 _sourceQuantity,
+ uint256 _destinationQuantity,
+ bytes calldata _data
+ )
+ external
+ view
+ returns (address, uint256, bytes memory)
+ {
+ // For a single hop trade, `_data.length` is 44. 20 source/destination token address + 3 fees +
+ // 20 source/destination token address + 1 fixInput bool.
+ // For multi-hop trades, `_data.length` is greater than 44.
+ require(_data.length >= 44, "Invalid data");
+
+ bool fixInput = toBool(_data, _data.length - 1); // `fixInput` bool is stored at last byte
+
+ address sourceFromPath;
+ address destinationFromPath;
+
+ if (fixInput) {
+ sourceFromPath = _data.toAddress(0);
+ destinationFromPath = _data.toAddress(_data.length - 21);
+ } else {
+ // Path for exactOutput swaps are reversed
+ sourceFromPath = _data.toAddress(_data.length - 21);
+ destinationFromPath = _data.toAddress(0);
+ }
+
+ require(_sourceToken == sourceFromPath, "Source token path mismatch");
+ require(_destinationToken == destinationFromPath, "Destination token path mismatch");
+
+ bytes memory pathData = _data.slice(0, _data.length - 1); // Extract path data from `_data`
+
+ bytes memory callData = fixInput
+ ? abi.encodeWithSelector(
+ ISwapRouter.exactInput.selector,
+ ISwapRouter.ExactInputParams(
+ pathData,
+ _destinationAddress,
+ block.timestamp,
+ _sourceQuantity,
+ _destinationQuantity
+ )
+ )
+  : abi.encodeWithSelector(
+ ISwapRouter.exactOutput.selector,
+ ISwapRouter.ExactOutputParams(
+ pathData,
+ _destinationAddress,
+ block.timestamp,
+ _destinationQuantity, // swapped vs exactInputParams
+ _sourceQuantity
+ )
+ );
+
+ return (swapRouter, 0, callData);
+ }
+
+ /**
+ * Returns the address to approve source tokens to for trading. This is the Uniswap SwapRouter address
+ *
+ * @return address Address of the contract to approve tokens to
+ */
+ function getSpender() external view returns (address) {
+ return swapRouter;
+ }
+
+ /**
+ * Returns the appropriate _data argument for getTradeCalldata. Equal to the encodePacked path with the
+ * fee of each hop between it and fixInput bool at the very end., e.g [token1, fee1, token2, fee2, token3, fixIn].
+ * Note: _fees.length == _path.length - 1
+ *
+ * @param _path array of addresses to use as the path for the trade
+ * @param _fees array of uint24 representing the pool fee to use for each hop
+ * @param _fixIn Boolean indicating if input amount is fixed
+ *
+ * @return bytes Bytes containing trade path and bool to determine function string.
+ */
+ function generateDataParam(
+ address[] calldata _path,
+ uint24[] calldata _fees,
+ bool _fixIn
+ ) external pure returns (bytes memory) {
+ bytes memory data = "";
+ for (uint256 i = 0; i < _path.length - 1; i++) {
+ data = abi.encodePacked(data, _path[i], _fees[i]);
+ }
+
+ // Last encode has no fee associated with it since _fees.length == _path.length - 1
+ data = abi.encodePacked(data, _path[_path.length - 1]);
+
+ // Encode fixIn
+ return abi.encodePacked(data, _fixIn);
+ }
+
+ /**
+ * Helper function to decode bytes to boolean. Similar to functions found in BytesLib.
+ * Note: Access modifier is set to public to enable complete testing.
+ */
+ function toBool(bytes memory _bytes, uint256 _start) public pure returns (bool) {
+ require(_start + 1 >= _start, "toBool_overflow");
+ require(_bytes.length >= _start + 1, "toBool_outOfBounds");
+ uint8 tempUint;
+
+ assembly {
+ tempUint := mload(add(add(_bytes, 0x1), _start))
+ }
+
+ require(tempUint <= 1, "Invalid bool data"); // Should be either 0 or 1
+
+ return (tempUint == 0) ? false : true;
+ }
+}