@harvest-finance/harvest-strategy-polygon 0.0.1-security → 1.0.0

package/test/curve/aave.js

@@ -0,0 +1,132 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const {
+  impersonates,
+  setupCoreProtocol,
+  depositVault,
+  swapMaticToToken,
+  addLiquidity
+} = require("../utilities/hh-utils.js");
+
+const addresses = require("../test-config.js");
+const { send } = require("@openzeppelin/test-helpers");
+const BigNumber = require("bignumber.js");
+const IERC20 = artifacts.require("IERC20");
+
+//const Strategy = artifacts.require("");
+const Strategy = artifacts.require("CurveStrategyAaveMainnet");
+const IDeposit = artifacts.require("ICurveDeposit_3token_underlying");
+
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Polygon Mainnet Curve Aave", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let usdc = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+  let depositAddr = "0x445FE580eF8d70FF569aB36e80c647af338db351";
+  let deposit;
+
+  // parties in the protocol
+  let governance;
+  let farmer1;
+
+  // numbers used in tests
+  let farmerBalance;
+
+  // Core protocol contracts
+  let controller;
+  let vault;
+  let strategy;
+
+  async function setupExternalContracts() {
+    underlying = await IERC20.at("0xE7a24EF0C5e95Ffb0f6684b813A78F2a3AD7D171");
+    console.log("Fetching Underlying at: ", underlying.address);
+  }
+
+  async function setupBalance(){
+    token1 = await IERC20.at(usdc);
+    await swapMaticToToken (
+      farmer1,
+      [addresses.WMATIC, token1.address],
+      "1000" + "000000000000000000",
+      addresses.QuickRouter
+    );
+    farmerToken1Balance = await token1.balanceOf(farmer1);
+    deposit = await IDeposit.at(depositAddr);
+    await token1.approve(depositAddr, farmerToken1Balance, { from:farmer1});
+    await deposit.add_liquidity([0, farmerToken1Balance, 0], 0, true, {from:farmer1});
+    farmerBalance = await underlying.balanceOf(farmer1);
+  }
+
+  before(async function() {
+    governance = "0xf00dD244228F51547f0563e60bCa65a30FBF5f7f";
+    accounts = await web3.eth.getAccounts();
+
+    farmer1 = accounts[1];
+
+    // impersonate accounts
+    await impersonates([governance]);
+
+    let etherGiver = accounts[9];
+    await send.ether(etherGiver, governance, "100" + "000000000000000000")
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+    });
+
+    await strategy.setSellFloor(0, {from:governance});
+
+    // whale send underlying to farmers
+    await setupBalance();
+  });
+
+  describe("Happy path", function() {
+    it("Farmer should earn money", async function() {
+      let farmerOldBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      await depositVault(farmer1, underlying, vault, farmerBalance);
+
+      // Using half days is to simulate how we doHardwork in the real world
+      // The rewards are time based and Hardhat propagates the chain with a block time of 16s
+      // So we have 225 blocks per hour, 2700 blocks per 12 hours.
+      let hours = 10;
+      let blocksPerHour = 2700;
+      let oldSharePrice;
+      let newSharePrice;
+      for (let i = 0; i < hours; i++) {
+        console.log("loop ", i);
+
+        oldSharePrice = new BigNumber(await vault.getPricePerFullShare());
+        await controller.doHardWork(vault.address, { from: governance });
+        newSharePrice = new BigNumber(await vault.getPricePerFullShare());
+
+        console.log("old shareprice: ", oldSharePrice.toFixed());
+        console.log("new shareprice: ", newSharePrice.toFixed());
+        console.log("growth: ", newSharePrice.toFixed() / oldSharePrice.toFixed());
+
+        await Utils.advanceNBlock(blocksPerHour);
+      }
+      await vault.withdraw(new BigNumber(await vault.balanceOf(farmer1)).toFixed(), { from: farmer1 });
+      let farmerNewBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      Utils.assertBNGt(farmerNewBalance, farmerOldBalance);
+
+      apr = (farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/225))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/225))+1)**365;
+
+      console.log("earned!");
+      console.log("APR:", apr*100, "%");
+      console.log("APY:", (apy-1)*100, "%");
+
+      await strategy.withdrawAllToVault({from:governance}); // making sure can withdraw all for a next switch
+
+    });
+  });
+});

package/test/curve/atricrypto3.js

@@ -0,0 +1,135 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const {
+  impersonates,
+  setupCoreProtocol,
+  depositVault,
+  swapMaticToToken,
+  addLiquidity
+} = require("../utilities/hh-utils.js");
+
+const addresses = require("../test-config.js");
+const { send } = require("@openzeppelin/test-helpers");
+const BigNumber = require("bignumber.js");
+const IERC20 = artifacts.require("IERC20");
+
+//const Strategy = artifacts.require("");
+const Strategy = artifacts.require("CurveStrategyAcricrypto3Mainnet");
+const IDeposit = artifacts.require("ICurveDeposit_5token");
+
+// test run with block number: 25091822
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Polygon Mainnet Curve atricrypto3", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let usdt = "0xc2132D05D31c914a87C6611C10748AEb04B58e8F";
+  let depositAddr = "0x1d8b86e3D88cDb2d34688e87E72F388Cb541B7C8";
+  let deposit;
+
+  // parties in the protocol
+  let governance;
+  let farmer1;
+
+  // numbers used in tests
+  let farmerBalance;
+
+  // Core protocol contracts
+  let controller;
+  let vault;
+  let strategy;
+
+  async function setupExternalContracts() {
+    underlying = await IERC20.at("0xdAD97F7713Ae9437fa9249920eC8507e5FbB23d3");
+    console.log("Fetching Underlying at: ", underlying.address);
+  }
+
+  async function setupBalance(){
+    token1 = await IERC20.at(usdt);
+    await swapMaticToToken (
+      farmer1,
+      [addresses.WMATIC, token1.address],
+      "1000" + "000000000000000000",
+      addresses.QuickRouter
+    );
+    farmerToken1Balance = await token1.balanceOf(farmer1);
+    console.log("farmerToken1Balance:", new BigNumber(farmerToken1Balance).toFixed());
+    deposit = await IDeposit.at(depositAddr);
+    await token1.approve(depositAddr, farmerToken1Balance, { from:farmer1});
+    await deposit.add_liquidity([0, 0, farmerToken1Balance, 0, 0], 0, {from:farmer1});
+    farmerBalance = await underlying.balanceOf(farmer1);
+  }
+
+  before(async function() {
+    governance = "0xf00dD244228F51547f0563e60bCa65a30FBF5f7f";
+    accounts = await web3.eth.getAccounts();
+
+    farmer1 = accounts[1];
+
+    // impersonate accounts
+    await impersonates([governance]);
+
+    let etherGiver = accounts[9];
+    await send.ether(etherGiver, governance, "100" + "000000000000000000")
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+    });
+
+    await strategy.setSellFloor(0, {from:governance});
+
+    // whale send underlying to farmers
+    await setupBalance();
+  });
+
+  describe("Happy path", function() {
+    it("Farmer should earn money", async function() {
+      let farmerOldBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      await depositVault(farmer1, underlying, vault, farmerBalance);
+
+      // Using half days is to simulate how we doHardwork in the real world
+      // The rewards are time based and polygon network has according to https://polygonscan.com/chart/blocks
+      // 30'000 to 41'000 blocks per day, lets assume 35'00 blocks per day therefore we have about 1500 blocks per hour (35'000 / 24= ~1459)
+      // therfore we have 12*1500 = 18'000 blocks per 12 hours
+      let hours = 10;
+      let blocksPerHour = 12*1500;
+      let oldSharePrice;
+      let newSharePrice;
+      for (let i = 0; i < hours; i++) {
+        console.log("loop ", i);
+
+        oldSharePrice = new BigNumber(await vault.getPricePerFullShare());
+        await controller.doHardWork(vault.address, { from: governance });
+        newSharePrice = new BigNumber(await vault.getPricePerFullShare());
+
+        console.log("old shareprice: ", oldSharePrice.toFixed());
+        console.log("new shareprice: ", newSharePrice.toFixed());
+        console.log("growth: ", newSharePrice.toFixed() / oldSharePrice.toFixed());
+
+        await Utils.advanceNBlock(blocksPerHour);
+      }
+      await vault.withdraw(new BigNumber(await vault.balanceOf(farmer1)).toFixed(), { from: farmer1 });
+      let farmerNewBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      Utils.assertBNGt(farmerNewBalance, farmerOldBalance);
+
+      apr = (farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1500))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1500))+1)**365;
+
+      console.log("earned!");
+      console.log("APR:", apr*100, "%");
+      console.log("APY:", (apy-1)*100, "%");
+
+      await strategy.withdrawAllToVault({from:governance}); // making sure can withdraw all for a next switch
+
+    });
+  });
+});

package/test/curve/eurtusd.js

@@ -0,0 +1,135 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const {
+  impersonates,
+  setupCoreProtocol,
+  depositVault,
+  swapMaticToToken,
+  addLiquidity
+} = require("../utilities/hh-utils.js");
+
+const addresses = require("../test-config.js");
+const { send } = require("@openzeppelin/test-helpers");
+const BigNumber = require("bignumber.js");
+const IERC20 = artifacts.require("IERC20");
+
+//const Strategy = artifacts.require("");
+const Strategy = artifacts.require("CurveStrategyEurtusdMainnet");
+const IDeposit = artifacts.require("ICurveDeposit_4token");
+
+// test run with block number: 25091822
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Polygon Mainnet Curve eurtusd", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let dai = "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063";
+  let depositAddr = "0x225FB4176f0E20CDb66b4a3DF70CA3063281E855";
+  let deposit;
+
+  // parties in the protocol
+  let governance;
+  let farmer1;
+
+  // numbers used in tests
+  let farmerBalance;
+
+  // Core protocol contracts
+  let controller;
+  let vault;
+  let strategy;
+
+  async function setupExternalContracts() {
+    underlying = await IERC20.at("0x600743B1d8A96438bD46836fD34977a00293f6Aa");
+    console.log("Fetching Underlying at: ", underlying.address);
+  }
+
+  async function setupBalance(){
+    token1 = await IERC20.at(dai);
+    await swapMaticToToken (
+      farmer1,
+      [addresses.WMATIC, token1.address],
+      "1000" + "000000000000000000",
+      addresses.QuickRouter
+    );
+    farmerToken1Balance = await token1.balanceOf(farmer1);
+    console.log("farmerToken1Balance:", new BigNumber(farmerToken1Balance).toFixed());
+    deposit = await IDeposit.at(depositAddr);
+    await token1.approve(depositAddr, farmerToken1Balance, { from:farmer1});
+    await deposit.add_liquidity([0, farmerToken1Balance, 0, 0], 0, {from:farmer1});
+    farmerBalance = await underlying.balanceOf(farmer1);
+  }
+
+  before(async function() {
+    governance = "0xf00dD244228F51547f0563e60bCa65a30FBF5f7f";
+    accounts = await web3.eth.getAccounts();
+
+    farmer1 = accounts[1];
+
+    // impersonate accounts
+    await impersonates([governance]);
+
+    let etherGiver = accounts[9];
+    await send.ether(etherGiver, governance, "100" + "000000000000000000")
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+    });
+
+    await strategy.setSellFloor(0, {from:governance});
+
+    // whale send underlying to farmers
+    await setupBalance();
+  });
+
+  describe("Happy path", function() {
+    it("Farmer should earn money", async function() {
+      let farmerOldBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      await depositVault(farmer1, underlying, vault, farmerBalance);
+
+      // Using half days is to simulate how we doHardwork in the real world
+      // The rewards are time based and polygon network has according to https://polygonscan.com/chart/blocks
+      // 30'000 to 41'000 blocks per day, lets assume 35'00 blocks per day therefore we have about 1500 blocks per hour (35'000 / 24= ~1459)
+      // therfore we have 12*1500 = 18'000 blocks per 12 hours
+      let hours = 10;
+      let blocksPerHour = 18000;
+      let oldSharePrice;
+      let newSharePrice;
+      for (let i = 0; i < hours; i++) {
+        console.log("loop ", i);
+
+        oldSharePrice = new BigNumber(await vault.getPricePerFullShare());
+        await controller.doHardWork(vault.address, { from: governance });
+        newSharePrice = new BigNumber(await vault.getPricePerFullShare());
+
+        console.log("old shareprice: ", oldSharePrice.toFixed());
+        console.log("new shareprice: ", newSharePrice.toFixed());
+        console.log("growth: ", newSharePrice.toFixed() / oldSharePrice.toFixed());
+
+        await Utils.advanceNBlock(blocksPerHour);
+      }
+      await vault.withdraw(new BigNumber(await vault.balanceOf(farmer1)).toFixed(), { from: farmer1 });
+      let farmerNewBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      Utils.assertBNGt(farmerNewBalance, farmerOldBalance);
+
+      apr = (farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1500))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1500))+1)**365;
+
+      console.log("earned!");
+      console.log("APR:", apr*100, "%");
+      console.log("APY:", (apy-1)*100, "%");
+
+      await strategy.withdrawAllToVault({from:governance}); // making sure can withdraw all for a next switch
+
+    });
+  });
+});

package/test/gamma-merkl/qs-eth-usdc.js

@@ -0,0 +1,212 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const { impersonates, setupCoreProtocol, depositVault } = require("../utilities/hh-utils.js");
+
+const addresses = require("../test-config.js");
+const BigNumber = require("bignumber.js");
+const IERC20 = artifacts.require("@openzeppelin/contracts/token/ERC20/IERC20.sol:IERC20");
+
+const Strategy = artifacts.require("GammaMerklStrategyMainnet_QS_ETH_USDC");
+
+//This test was developed at blockNumber 53865380
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Mainnet Quickswap-Gamma ETH-USDC", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+  let quick;
+
+  // external setup
+  let underlyingWhale = "0x539460Bd8D7d6130ce6C4A65c0b59DA3b3d2da42";
+  let quickWhale = "0x41dd65795c24273A3e3B910ea3e2D7866F5AFDDa";
+  let quickAddr = "0xB5C064F955D8e7F38fE0460C556a72987494eE17";
+  let usdc = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+  let weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+
+  // parties in the protocol
+  let governance;
+  let farmer1;
+
+  // numbers used in tests
+  let farmerBalance;
+
+  // Core protocol contracts
+  let controller;
+  let vault;
+  let strategy;
+
+  async function setupExternalContracts() {
+    underlying = await IERC20.at("0x3974FbDC22741A1632E024192111107b202F214f");
+    quick = await IERC20.at(quickAddr);
+    console.log("Fetching Underlying at: ", underlying.address);
+  }
+
+  async function setupBalance(){
+    let etherGiver = accounts[9];
+    // Give whale some ether to make sure the following actions are good
+    await web3.eth.sendTransaction({ from: etherGiver, to: underlyingWhale, value: 100e18});
+    await web3.eth.sendTransaction({ from: etherGiver, to: quickWhale, value: 100e18});
+
+    farmerBalance = await underlying.balanceOf(underlyingWhale);
+    await underlying.transfer(farmer1, farmerBalance, { from: underlyingWhale });
+  }
+
+  before(async function() {
+    governance = addresses.Governance;
+    accounts = await web3.eth.getAccounts();
+
+    farmer1 = accounts[1];
+
+    // impersonate accounts
+    await impersonates([governance, underlyingWhale, quickWhale]);
+
+    let etherGiver = accounts[9];
+    await web3.eth.sendTransaction({ from: etherGiver, to: governance, value: 100e18});
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+      "liquidation": [
+        {"uniV3": [weth, usdc]},
+      ],
+    });
+
+    // whale send underlying to farmers
+    await setupBalance();
+  });
+
+  describe("Happy path", function() {
+    it("Farmer should earn money", async function() {
+      let farmerOldBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      console.log("Farmer old balance:", farmerOldBalance.toFixed());
+      await depositVault(farmer1, underlying, vault, farmerBalance);
+      let fTokenBalance = new BigNumber(await vault.balanceOf(farmer1));
+      console.log("Farmer fToken balance:", fTokenBalance.toFixed());
+
+      // Using half days is to simulate how we doHardwork in the real world
+      let hours = 10;
+      let blocksPerHour = 1565*5;
+      let oldSharePrice;
+      let newSharePrice;
+      for (let i = 0; i < hours; i++) {
+        console.log("loop ", i);
+
+        await quick.transfer(strategy.address, new BigNumber(100e18), { from: quickWhale });
+
+        oldSharePrice = new BigNumber(await vault.getPricePerFullShare());
+        await controller.doHardWork(vault.address, { from: governance });
+        newSharePrice = new BigNumber(await vault.getPricePerFullShare());
+
+        console.log("old shareprice: ", oldSharePrice.toFixed());
+        console.log("new shareprice: ", newSharePrice.toFixed());
+        console.log("growth: ", newSharePrice.toFixed() / oldSharePrice.toFixed());
+
+        apr = (newSharePrice.toFixed()/oldSharePrice.toFixed()-1)*(24/(blocksPerHour/1565))*365;
+        apy = ((newSharePrice.toFixed()/oldSharePrice.toFixed()-1)*(24/(blocksPerHour/1565))+1)**365;
+
+        console.log("instant APR:", apr*100, "%");
+        console.log("instant APY:", (apy-1)*100, "%");
+
+        await Utils.advanceNBlock(blocksPerHour);
+      }
+      await vault.withdraw(fTokenBalance, { from: farmer1 });
+      let farmerNewBalance = new BigNumber(await underlying.balanceOf(farmer1));
+      Utils.assertBNGt(farmerNewBalance, farmerOldBalance);
+
+      apr = (farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1565))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1565))+1)**365;
+
+      console.log("earned!");
+      console.log("Overall APR:", apr*100, "%");
+      console.log("Overall APY:", (apy-1)*100, "%");
+
+      await strategy.withdrawAllToVault({ from: governance }); // making sure can withdraw all for a next switch
+    });
+  });
+
+
+
+  describe("Basic strategy functionality checks", function () {
+    it("Deposit to vault", async function () {
+      // deposit to vault such that we have something to work with
+      await depositVault(farmer1, underlying, vault, farmerBalance);
+
+      // check vault has at least farmerBalance (there could be some dust etc., so no exact check)
+      let vaultUnderlying = new BigNumber(await vault.underlyingBalanceInVault());
+      Utils.assertBNGte(vaultUnderlying, farmerBalance)
+    });
+
+    it("withdrawAllToVault()", async function () {
+      let vaultUnderlying = new BigNumber(await vault.underlyingBalanceInVault());
+      // doHardwork invests all underlying from the vault
+      await controller.doHardWork(vault.address, { from: governance });
+      let investedUnderlyingBalance = new BigNumber(await strategy.investedUnderlyingBalance());
+
+      // strategy invested amount must be greater or equal than the initial vault underlying amount
+      Utils.assertBNGte(investedUnderlyingBalance, vaultUnderlying)
+
+      // move all invested underlying back to the vault
+      await strategy.withdrawAllToVault({ from: governance });
+
+      // strategy has no underlying left
+      let investedUnderlyingBalanceNew = new BigNumber(await strategy.investedUnderlyingBalance());
+      assert.equal(investedUnderlyingBalanceNew.eq(BigNumber(0)), true);
+
+      // vault has all of the underlying from the strategy
+      let vaultUnderlyingNew = new BigNumber(await vault.underlyingBalanceInVault());
+      Utils.assertBNGte(vaultUnderlyingNew, investedUnderlyingBalance)
+    });
+
+    it("withdrawToVault(uint256 _amount)", async function () {
+      let vaultUnderlying = new BigNumber(await vault.underlyingBalanceInVault());
+      // doHardwork invests all underlying from the vault
+      await controller.doHardWork(vault.address, { from: governance });
+      let investedUnderlyingBalance = new BigNumber(await strategy.investedUnderlyingBalance());
+
+      // strategy invested amount must be greater or equal than the initial vault underlying amount
+      Utils.assertBNGte(investedUnderlyingBalance, vaultUnderlying)
+
+      let amount = 1;
+      // move amount of underlying to vault
+      await strategy.withdrawToVault(amount, { from: governance });
+
+      // vault has exactly amount of underlying
+      let vaultUnderlyingNew = new BigNumber(await vault.underlyingBalanceInVault());
+      assert.equal(new BigNumber(amount).eq(vaultUnderlyingNew), true);
+    });
+
+    it("unsalvagableTokens(address _token)", async function () {
+      // underlying is unsalvageable
+      let isUnderlyingUnsalvagable = await strategy.unsalvagableTokens(underlying.address);
+      assert.equal(isUnderlyingUnsalvagable, true);
+
+      // rewardToken is unsalvageable
+      let isRewardTokenUnsalvagable = await strategy.unsalvagableTokens(await strategy.rewardToken());
+      assert.equal(isRewardTokenUnsalvagable, true);
+
+    });
+
+    it("Remove all deposited LP tokens", async function () {
+      // remove all deposited LP tokens
+      let fTokenBalance = await vault.balanceOf(farmer1);
+      await vault.withdraw(fTokenBalance, { from: farmer1 });
+
+      //check that there is nothing left in the strategy or vault
+      let strategyBalance = new BigNumber(await underlying.balanceOf(strategy.address));
+      assert.equal(strategyBalance.eq(BigNumber(0)), true);
+
+      let vaultBalance = new BigNumber(await underlying.balanceOf(vault.address));
+      assert.equal(vaultBalance.eq(BigNumber(0)), true);
+
+      let totalUnderlyingVaultAndStrategy = new BigNumber(await vault.underlyingBalanceWithInvestment());
+      assert.equal(totalUnderlyingVaultAndStrategy.eq(BigNumber(0)), true);
+    });
+  });
+
+});