Update FLI viewer for multihop

Author: richardliang

contracts/viewers/FLIRebalanceViewer.sol

@@ -32,8 +32,12 @@ import { PreciseUnitMath } from "../lib/PreciseUnitMath.sol";
  * @title FLIRebalanceViewer
  * @author Set Protocol
  *
- * ETHFLI Rebalance viewer that returns whether a Compound oracle update should be forced before a rebalance goes through, if no
+ * FLI Rebalance viewer that returns whether a Compound oracle update should be forced before a rebalance goes through, if no
  * oracle update the type of rebalance transaction will be returned adhering to the enum specified in FlexibleLeverageStrategyAdapter
+ *
+ * CHANGELOG: 4/28/2021
+ * - Enables calculating Uniswap price with any multihop route
+ * - Lever and delever exchange data is read directly from strategy adapter and if not empty, calculate price based on encoded route
  */
 contract FLIRebalanceViewer {
     using PreciseUnitMath for uint256;
@@ -163,17 +167,25 @@ contract FLIRebalanceViewer {
         view
         returns (uint256)
     {
-        address[] memory path = new address[](2);
-        path[0] = _sellAsset;
-        path[1] = _buyAsset;
+        bytes memory pathCalldata = _isBuyingCollateral ? strategyAdapter.getExecution().leverExchangeData : strategyAdapter.getExecution().deleverExchangeData;
+
+        address[] memory path;
+        if(pathCalldata.length == 0){
+            path = new address[](2);
+            path[0] = _sellAsset;
+            path[1] = _buyAsset;
+        } else {
+            path = abi.decode(pathCalldata, (address[]));
+        }
 
         // Returned [sellAmount, buyAmount]
         uint256[] memory flows = _isBuyingCollateral ? uniswapRouter.getAmountsIn(_tradeSize, path) : uniswapRouter.getAmountsOut(_tradeSize, path);
 
         uint256 buyDecimals = uint256(10)**ERC20(_buyAsset).decimals();
         uint256 sellDecimals = uint256(10)**ERC20(_sellAsset).decimals();
 
-        return flows[0].preciseDiv(sellDecimals).preciseDiv(flows[1].preciseDiv(buyDecimals));
+        uint256 lastIndex = path.length.sub(1);
+        return flows[0].preciseDiv(sellDecimals).preciseDiv(flows[lastIndex].preciseDiv(buyDecimals));
     }
 
     /**

test/viewers/fliRebalanceViewer.spec.ts

@@ -1,5 +1,6 @@
 import "module-alias/register";
 import { BigNumber } from "@ethersproject/bignumber";
+import { defaultAbiCoder } from "ethers/lib/utils";
 
 import {
   Account,
@@ -14,6 +15,7 @@ import { CompoundLeverageModule, DebtIssuanceModule, SetToken } from "@utils/con
 import { CEther, CERc20 } from "@utils/contracts/compound";
 import DeployHelper from "@utils/deploys";
 import {
+  bitcoin,
   cacheBeforeEach,
   ether,
   getAccounts,
@@ -103,6 +105,7 @@ describe("FLIRebalanceViewer", () => {
 
     await setV2Setup.weth.connect(owner.wallet).approve(uniswapSetup.router.address, MAX_UINT_256);
     await setV2Setup.usdc.connect(owner.wallet).approve(uniswapSetup.router.address, MAX_UINT_256);
+    await setV2Setup.wbtc.connect(owner.wallet).approve(uniswapSetup.router.address, MAX_UINT_256);
     await uniswapSetup.router.addLiquidity(
       setV2Setup.weth.address,
       setV2Setup.usdc.address,
@@ -113,6 +116,26 @@ describe("FLIRebalanceViewer", () => {
       owner.address,
       MAX_UINT_256
     );
+    await uniswapSetup.router.addLiquidity(
+      setV2Setup.wbtc.address,
+      setV2Setup.usdc.address,
+      bitcoin(100),
+      usdc(5000000),
+      bitcoin(99),
+      usdc(4000000),
+      owner.address,
+      MAX_UINT_256
+    );
+    await uniswapSetup.router.addLiquidity(
+      setV2Setup.wbtc.address,
+      setV2Setup.weth.address,
+      bitcoin(100),
+      ether(5000),
+      bitcoin(99),
+      ether(4000),
+      owner.address,
+      MAX_UINT_256
+    );
 
     // Mint cTokens
     await setV2Setup.usdc.approve(cUSDC.address, ether(100000));
@@ -581,5 +604,96 @@ describe("FLIRebalanceViewer", () => {
         });
       });
     });
+
+    context.only("when there is a multihop trade", async () => {
+      describe("when above max leverage ratio but below incentivized leverage ratio", async () => {
+        beforeEach(async () => {
+          await compoundSetup.priceOracle.setUnderlyingPrice(cEther.address, ether(850));
+
+          await flexibleLeverageStrategyAdapter.setExecutionSettings(
+            {
+              unutilizedLeveragePercentage: execution.unutilizedLeveragePercentage,
+              twapMaxTradeSize: execution.twapMaxTradeSize,
+              twapCooldownPeriod: execution.twapCooldownPeriod,
+              slippageTolerance: execution.slippageTolerance,
+              exchangeName: "UniswapTradeAdapter",
+              leverExchangeData: EMPTY_BYTES,
+              deleverExchangeData: defaultAbiCoder.encode(
+                ["address[]"],
+                [[setV2Setup.weth.address, setV2Setup.wbtc.address, setV2Setup.usdc.address]]
+              ),
+            }
+          );
+        });
+
+        it("should return rebalance", async () => {
+          const shouldRebalance = await subject();
+
+          expect(shouldRebalance).to.eq(ONE);
+        });
+
+        describe("but Uniswap slippage would exceed bounds", async () => {
+          beforeEach(async () => {
+            await setUniswapPoolToPrice(
+              uniswapSetup.router,
+              uniswapSetup.wethWbtcPool,
+              setV2Setup.weth,
+              setV2Setup.wbtc,
+              ether(0.01),
+              owner.address
+            );
+          });
+
+          it("should return update oracle", async () => {
+            const shouldRebalance = await subject();
+
+            expect(shouldRebalance).to.eq(FOUR);
+          });
+        });
+      });
+
+      describe("when below min leverage ratio", async () => {
+        beforeEach(async () => {
+          await compoundSetup.priceOracle.setUnderlyingPrice(cEther.address, ether(1400));
+
+          await flexibleLeverageStrategyAdapter.setExecutionSettings(
+            {
+              unutilizedLeveragePercentage: execution.unutilizedLeveragePercentage,
+              twapMaxTradeSize: execution.twapMaxTradeSize,
+              twapCooldownPeriod: execution.twapCooldownPeriod,
+              slippageTolerance: execution.slippageTolerance,
+              exchangeName: "UniswapTradeAdapter",
+              leverExchangeData: defaultAbiCoder.encode(["address[]"], [[setV2Setup.usdc.address, setV2Setup.wbtc.address, setV2Setup.weth.address]]),
+              deleverExchangeData: EMPTY_BYTES,
+            }
+          );
+        });
+
+        it("should return rebalance", async () => {
+          const shouldRebalance = await subject();
+
+          expect(shouldRebalance).to.eq(ONE);
+        });
+
+        describe("but Uniswap slippage would exceed bounds", async () => {
+          beforeEach(async () => {
+            await setUniswapPoolToPrice(
+              uniswapSetup.router,
+              uniswapSetup.wethWbtcPool,
+              setV2Setup.weth,
+              setV2Setup.wbtc,
+              ether(0.06),
+              owner.address
+            );
+          });
+
+          it("should return update oracle", async () => {
+            const shouldRebalance = await subject();
+
+            expect(shouldRebalance).to.eq(FOUR);
+          });
+        });
+      });
+    });
   });
 });