Add sushi swap trade module integration test

Author: cgewecke

test/integration/sushiswapExchangeTradeModule.spec.ts

@@ -0,0 +1,203 @@
+import "module-alias/register";
+
+import { BigNumber } from "@ethersproject/bignumber";
+import { ethers } from "hardhat";
+
+import { Address, Bytes } from "@utils/types";
+import { Account } from "@utils/test/types";
+import { IERC20, UniswapV2Router02 } from "@typechain/index";
+import {
+  SetToken,
+  TradeModule,
+  ManagerIssuanceHookMock,
+  UniswapV2ExchangeAdapterV2,
+} from "@utils/contracts";
+import { ZERO } from "@utils/constants";
+import DeployHelper from "@utils/deploys";
+import {
+  ether,
+  bitcoin,
+} from "@utils/index";
+import {
+  cacheBeforeEach,
+  getAccounts,
+  getSystemFixture,
+  getWaffleExpect,
+  getUniswapFixture,
+  getForkedTokens,
+  initializeForkedTokens,
+  ForkedTokens
+} from "@utils/test/index";
+
+import { SystemFixture, UniswapFixture } from "@utils/fixtures";
+
+const expect = getWaffleExpect();
+
+describe("SushiSwap TradeModule Integration [ @forked-mainnet ]", () => {
+  let owner: Account;
+  let manager: Account;
+
+  let deployer: DeployHelper;
+
+  let uniswapExchangeAdapterV2: UniswapV2ExchangeAdapterV2;
+  let uniswapAdapterV2Name: string;
+
+  let setup: SystemFixture;
+  let sushiswapSetup: UniswapFixture;
+  let sushiswapRouter: UniswapV2Router02;
+  let tradeModule: TradeModule;
+  let tokens: ForkedTokens;
+  let wbtcRate: BigNumber;
+
+  before(async () => {
+    [
+      owner,
+      manager,
+    ] = await getAccounts();
+
+
+    deployer = new DeployHelper(owner.wallet);
+    setup = getSystemFixture(owner.address);
+    await setup.initialize();
+
+    wbtcRate = ether(29);
+
+    sushiswapSetup = getUniswapFixture(owner.address);
+    sushiswapRouter = sushiswapSetup.getForkedSushiswapRouter();
+
+    uniswapExchangeAdapterV2 = await deployer.adapters.deployUniswapV2ExchangeAdapterV2(sushiswapRouter.address);
+    uniswapAdapterV2Name = "UNISWAPV2";
+
+    tradeModule = await deployer.modules.deployTradeModule(setup.controller.address);
+    await setup.controller.addModule(tradeModule.address);
+
+    await setup.integrationRegistry.addIntegration(
+      tradeModule.address,
+      uniswapAdapterV2Name,
+      uniswapExchangeAdapterV2.address
+    );
+
+    await initializeForkedTokens(deployer);
+  });
+
+  describe("#trade", function() {
+    let sourceToken: IERC20;
+    let wbtcUnits: BigNumber;
+    let destinationToken: IERC20;
+    let setToken: SetToken;
+    let issueQuantity: BigNumber;
+
+    context("when trading a Default component on Sushiswap (version 2 adapter)", async () => {
+      let mockPreIssuanceHook: ManagerIssuanceHookMock;
+      let sourceTokenQuantity: BigNumber;
+      let destinationTokenQuantity: BigNumber;
+
+      let subjectDestinationToken: Address;
+      let subjectSourceToken: Address;
+      let subjectSourceQuantity: BigNumber;
+      let subjectAdapterName: string;
+      let subjectSetToken: Address;
+      let subjectMinDestinationQuantity: BigNumber;
+      let subjectData: Bytes;
+      let subjectCaller: Account;
+
+      cacheBeforeEach(async () => {
+        tokens = getForkedTokens();
+
+        sourceToken = tokens.wbtc;
+        destinationToken = tokens.weth;
+        wbtcUnits = BigNumber.from(100000000); // 1 WBTC in base units 1 * 10 ** 8
+
+        // Create Set token
+        setToken = await setup.createSetToken(
+          [sourceToken.address],
+          [wbtcUnits],
+          [setup.issuanceModule.address, tradeModule.address],
+          manager.address
+        );
+
+        await sourceToken.approve(sushiswapRouter.address, bitcoin(100));
+        await destinationToken.approve(sushiswapRouter.address, ether(3400));
+
+        tradeModule = tradeModule.connect(manager.wallet);
+        await tradeModule.initialize(setToken.address);
+
+        sourceTokenQuantity = wbtcUnits;
+        const sourceTokenDecimals = 8;
+        destinationTokenQuantity = wbtcRate.mul(sourceTokenQuantity).div(10 ** sourceTokenDecimals);
+
+        // Transfer from wbtc whale to manager
+        await sourceToken.transfer(manager.address, wbtcUnits.mul(1));
+
+        // Approve tokens to Controller and call issue
+        sourceToken = sourceToken.connect(manager.wallet);
+        await sourceToken.approve(setup.issuanceModule.address, ethers.constants.MaxUint256);
+
+        // Deploy mock issuance hook and initialize issuance module
+        setup.issuanceModule = setup.issuanceModule.connect(manager.wallet);
+        mockPreIssuanceHook = await deployer.mocks.deployManagerIssuanceHookMock();
+        await setup.issuanceModule.initialize(setToken.address, mockPreIssuanceHook.address);
+
+        issueQuantity = ether(1);
+        await setup.issuanceModule.issue(setToken.address, issueQuantity, owner.address);
+      });
+
+      beforeEach(async () => {
+        subjectSourceToken = sourceToken.address;
+        subjectDestinationToken = destinationToken.address;
+        subjectSourceQuantity = sourceTokenQuantity;
+        subjectSetToken = setToken.address;
+        subjectMinDestinationQuantity = destinationTokenQuantity.sub(ether(1)); // Receive a min of 28 WETH for 1 WBTC
+        subjectAdapterName = uniswapAdapterV2Name;
+
+        const tradePath = [subjectSourceToken, subjectDestinationToken];
+        const shouldSwapForExactToken = false;
+
+        subjectData = await uniswapExchangeAdapterV2.getUniswapExchangeData(
+          tradePath,
+          shouldSwapForExactToken
+        );
+        subjectCaller = manager;
+      });
+
+      async function subject(): Promise<any> {
+        tradeModule = tradeModule.connect(subjectCaller.wallet);
+        return tradeModule.trade(
+          subjectSetToken,
+          subjectAdapterName,
+          subjectSourceToken,
+          subjectSourceQuantity,
+          subjectDestinationToken,
+          subjectMinDestinationQuantity,
+          subjectData
+        );
+      }
+
+      it("should transfer the correct components to the SetToken", async () => {
+        const oldDestinationTokenBalance = await destinationToken.balanceOf(setToken.address);
+        const [, expectedReceiveQuantity] = await sushiswapRouter.getAmountsOut(
+          subjectSourceQuantity,
+          [subjectSourceToken, subjectDestinationToken]
+        );
+
+        await subject();
+
+        const expectedDestinationTokenBalance = oldDestinationTokenBalance.add(expectedReceiveQuantity);
+        const newDestinationTokenBalance = await destinationToken.balanceOf(setToken.address);
+        expect(expectedReceiveQuantity).to.be.gt(ZERO);
+        expect(newDestinationTokenBalance).to.eq(expectedDestinationTokenBalance);
+      });
+
+      it("should transfer the correct components from the SetToken", async () => {
+        const oldSourceTokenBalance = await sourceToken.balanceOf(setToken.address);
+
+        await subject();
+
+        const totalSourceQuantity = issueQuantity.mul(sourceTokenQuantity).div(ether(1));
+        const expectedSourceTokenBalance = oldSourceTokenBalance.sub(totalSourceQuantity);
+        const newSourceTokenBalance = await sourceToken.balanceOf(setToken.address);
+        expect(newSourceTokenBalance).to.eq(expectedSourceTokenBalance);
+      });
+    });
+  });
+});

test/integration/uniswapV2ExchangeTradeModule.spec.ts

@@ -33,7 +33,7 @@ import { SystemFixture, UniswapFixture } from "@utils/fixtures";
 
 const expect = getWaffleExpect();
 
-describe("UniswapExchangeV2TradeModule [ @forked-mainnet ]", () => {
+describe("UniswapExchangeV2 TradeModule Integration [ @forked-mainnet ]", () => {
   let owner: Account;
   let manager: Account;
 
@@ -63,7 +63,7 @@ describe("UniswapExchangeV2TradeModule [ @forked-mainnet ]", () => {
     wbtcRate = ether(29);
 
     uniswapSetup = getUniswapFixture(owner.address);
-    uniswapRouter = uniswapSetup.getForkedRouterInstance();
+    uniswapRouter = uniswapSetup.getForkedUniswapRouter();
 
     uniswapExchangeAdapterV2 = await deployer.adapters.deployUniswapV2ExchangeAdapterV2(uniswapRouter.address);
     uniswapAdapterV2Name = "UNISWAPV2";

test/integration/zeroExExchangeTradeModule.spec.ts

@@ -31,7 +31,7 @@ import { SystemFixture } from "@utils/fixtures";
 
 const expect = getWaffleExpect();
 
-describe("ZeroExExchangeTradeModule [ @forked-mainnet ]", () => {
+describe("ZeroExExchange TradeModule Integration [ @forked-mainnet ]", () => {
   let owner: Account;
   let manager: Account;
 

utils/fixtures/uniswapFixture.ts

@@ -98,7 +98,11 @@ export class UniswapFixture {
     return _tokenOne.toLowerCase() < _tokenTwo.toLowerCase() ? [_tokenOne, _tokenTwo] : [_tokenTwo, _tokenOne];
   }
 
-  public getForkedRouterInstance(): UniswapV2Router02 {
+  public getForkedUniswapRouter(): UniswapV2Router02 {
     return this._deployer.external.getForkedUniswapV2Router02(dependencies.UNISWAP_ROUTER[1]);
   }
-}
+
+  public getForkedSushiswapRouter(): UniswapV2Router02 {
+    return this._deployer.external.getForkedUniswapV2Router02(dependencies.SUSHISWAP_ROUTER[1]);
+  }
+}