Add FLIRebalanceViewer (#65)

* add basic layout

* add basic contract logic and uniswap v3 contracts

* add uniswap v3 fixture

* fix deployment and constructor test

* add needed functions to FLIExtensionMock

* add tests

* fix bugs and refactor

* refactor

* add javadocs

* improve tests

* basic refactoring

* add ActionInfo struct to reduce duplication

* remove unused code

* add more info to ActionInfo

* fix indexing of chunk send quantity

* refactoring

* improve test coverage

* remove redundant exchangNames variable

Author: ncitron

contracts/interfaces/IFLIStrategyExtension.sol

@@ -24,6 +24,8 @@ interface IFLIStrategyExtension {
     function getMethodology() external view returns (FlexibleLeverageStrategyExtension.MethodologySettings memory);
     function getIncentive() external view returns (FlexibleLeverageStrategyExtension.IncentiveSettings memory);
     function getExecution() external view returns (FlexibleLeverageStrategyExtension.ExecutionSettings memory);
+    function getExchangeSettings(string memory _exchangeName) external view returns (FlexibleLeverageStrategyExtension.ExchangeSettings memory);
+    function getEnabledExchanges() external view returns (string[] memory);
 
     function getCurrentLeverageRatio() external view returns (uint256);
 

contracts/interfaces/IQuoter.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity 0.6.10;
+pragma experimental ABIEncoderV2;
+
+/// @title Quoter Interface
+/// @notice Supports quoting the calculated amounts from exact input or exact output swaps
+/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
+/// to compute the result. They are also not gas efficient and should not be called on-chain.
+interface IQuoter {
+    /// @notice Returns the amount out received for a given exact input swap without executing the swap
+    /// @param path The path of the swap, i.e. each token pair and the pool fee
+    /// @param amountIn The amount of the first token to swap
+    /// @return amountOut The amount of the last token that would be received
+    function quoteExactInput(bytes memory path, uint256 amountIn) external returns (uint256 amountOut);
+
+    /// @notice Returns the amount out received for a given exact input but for a swap of a single pool
+    /// @param tokenIn The token being swapped in
+    /// @param tokenOut The token being swapped out
+    /// @param fee The fee of the token pool to consider for the pair
+    /// @param amountIn The desired input amount
+    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
+    /// @return amountOut The amount of `tokenOut` that would be received
+    function quoteExactInputSingle(
+        address tokenIn,
+        address tokenOut,
+        uint24 fee,
+        uint256 amountIn,
+        uint160 sqrtPriceLimitX96
+    ) external returns (uint256 amountOut);
+
+    /// @notice Returns the amount in required for a given exact output swap without executing the swap
+    /// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
+    /// @param amountOut The amount of the last token to receive
+    /// @return amountIn The amount of first token required to be paid
+    function quoteExactOutput(bytes memory path, uint256 amountOut) external returns (uint256 amountIn);
+
+    /// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
+    /// @param tokenIn The token being swapped in
+    /// @param tokenOut The token being swapped out
+    /// @param fee The fee of the token pool to consider for the pair
+    /// @param amountOut The desired output amount
+    /// @param sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
+    /// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
+    function quoteExactOutputSingle(
+        address tokenIn,
+        address tokenOut,
+        uint24 fee,
+        uint256 amountOut,
+        uint160 sqrtPriceLimitX96
+    ) external returns (uint256 amountIn);
+}

contracts/mocks/FLIStrategyExtensionMock.sol

@@ -0,0 +1,87 @@
+pragma solidity 0.6.10;
+pragma experimental ABIEncoderV2;
+
+import { FlexibleLeverageStrategyExtension } from "../adapters/FlexibleLeverageStrategyExtension.sol";
+
+// Mock contract for FlexibleLeverageStrategyExtension used to test FLIRebalanceViewer
+contract FLIStrategyExtensionMock {
+
+    string[] internal shouldRebalanceNames;
+    FlexibleLeverageStrategyExtension.ShouldRebalance[] internal shouldRebalancesEnums;
+
+    uint256[] internal chunkRebalanceSizes;
+    address internal chunkRebalanceSellAsset;
+    address internal chunkRebalanceBuyAsset;
+
+    FlexibleLeverageStrategyExtension.ContractSettings internal strategy;
+
+    mapping(string => FlexibleLeverageStrategyExtension.ExchangeSettings) internal exchangeSettings;
+    
+
+    function shouldRebalanceWithBounds(
+        uint256 /* _customMinLeverageRatio */,
+        uint256 /* _customMaxLeverageRatio */
+    )
+        external
+        view
+        returns(string[] memory, FlexibleLeverageStrategyExtension.ShouldRebalance[] memory)
+    {
+        return (shouldRebalanceNames, shouldRebalancesEnums);
+    }
+
+    function getChunkRebalanceNotional(
+        string[] calldata /* _exchangeNames */
+    ) 
+        external
+        view
+        returns(uint256[] memory sizes, address sellAsset, address buyAsset)
+    {
+        sizes = chunkRebalanceSizes;
+        sellAsset = chunkRebalanceSellAsset;
+        buyAsset = chunkRebalanceBuyAsset;
+    }
+
+    function getStrategy() external view returns (FlexibleLeverageStrategyExtension.ContractSettings memory) {
+        return strategy;
+    }
+
+    function getExchangeSettings(string memory _exchangeName) external view returns (FlexibleLeverageStrategyExtension.ExchangeSettings memory) {
+        return exchangeSettings[_exchangeName];
+    }
+
+    function getEnabledExchanges() external view returns (string[] memory) {
+        return shouldRebalanceNames;
+    }
+
+    /* =========== Functions for setting mock state =========== */
+
+    function setShouldRebalanceWithBounds(
+        string[] memory _shouldRebalanceNames,
+        FlexibleLeverageStrategyExtension.ShouldRebalance[] memory _shouldRebalancesEnums
+    )
+        external
+    {
+        shouldRebalanceNames = _shouldRebalanceNames;
+        shouldRebalancesEnums = _shouldRebalancesEnums;
+    }
+
+    function setGetChunkRebalanceWithBounds(
+        uint256[] memory _chunkRebalanceSizes,
+        address _chunkRebalanceSellAsset,
+        address _chunkRebalanceBuyAsset
+    )
+        external
+    {
+        chunkRebalanceSizes = _chunkRebalanceSizes;
+        chunkRebalanceSellAsset = _chunkRebalanceSellAsset;
+        chunkRebalanceBuyAsset = _chunkRebalanceBuyAsset;
+    }
+
+    function setStrategy(FlexibleLeverageStrategyExtension.ContractSettings memory _strategy) external {
+        strategy = _strategy;
+    }
+
+    function setExchangeSettings(string memory _exchangeName, FlexibleLeverageStrategyExtension.ExchangeSettings memory _settings) external {
+        exchangeSettings[_exchangeName] = _settings;
+    }
+}