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

package/test/convex/usdr.js

@@ -0,0 +1,123 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const {
+  impersonates,
+  setupCoreProtocol,
+  depositVault,
+} = 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("ConvexStrategyMainnet_USDR");
+
+// Developed and tested at blockNumber 41679900
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Polygon Mainnet Convex USDR", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let underlyingWhale = "0xD60ACbaC798F146e4B7080E9a1f93977200f5cff";
+
+  // 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("0xa138341185a9D0429B0021A11FB717B225e13e1F");
+    console.log("Fetching Underlying at: ", underlying.address);
+  }
+
+  async function setupBalance(){
+    let etherGiver = accounts[9];
+    await send.ether(etherGiver, underlyingWhale, "100" + "000000000000000000");
+
+    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]);
+
+    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,
+    });
+
+    // 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
+      let hours = 10;
+      let blocksPerHour = 1565*5;
+      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());
+
+        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(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/1565))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1565))+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/core/emission-fork.js

@@ -0,0 +1,197 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const { impersonates, setupCoreProtocol, depositVault } = require("../utilities/hh-utils.js");
+
+const addresses = require("../../../matic-config/matic-addresses.json");
+const { send, expectRevert, time } = require("@openzeppelin/test-helpers");
+const BigNumber = require("bignumber.js");
+const IERC20Upgradeable = artifacts.require("IERC20Upgradeable");
+
+const Storage = artifacts.require("Storage");
+const NotifyHelperStateful = artifacts.require("NotifyHelperStateful");
+const NotifyHelperGeneric = artifacts.require("NotifyHelperGeneric");
+const GlobalIncentivesHelper = artifacts.require("GlobalIncentivesHelper");
+const Governable = artifacts.require("Governable");
+const Controllable = artifacts.require("Controllable");
+const PotPool = artifacts.require("PotPool");
+
+
+// block 21829169
+describe("Emission tests", function() {
+  let accounts;
+
+  let storage = addresses.Storage;
+  let governance = addresses.GOVERNANCE;
+  let notifyHelperRegular;
+  let nobody;
+
+  let usdcEurHolder = "0x08ac9c15aaf98563a4b19ddbd0153ff3516d65a8";
+  let usdcGbpHolder = "0x420674a75e1e158a3c675f13df1f26d51f22b502";
+  let usdcEurContract;
+  let usdcGbpContract;
+
+  let NotificationType = {
+      VOID : 0, AMPLIFARM : 1, FARM : 2, TRANSFER : 3, PROFIT_SHARE : 4, TOKEN: 5
+  }
+
+  // contracts
+  let miFARM;
+  let statefulHelper;
+  let helperStorage;
+  let globalIncentivesHelper;
+
+  let emission = [
+    {
+      address: "0xf25474FBf9812bE2ef76abf4297A27411C156403", // Jarvis: EUR-USDC
+      percentage: "1"
+    },
+    {
+      address: "0x877635e68C1E943D6d6B777C0e847Cd7aE5A01BE", // Jarvis: GBP-USDC
+      percentage: "2"
+    },
+  ]
+  let emissionMatic = [
+    {
+      address: "0xf25474FBf9812bE2ef76abf4297A27411C156403", // Jarvis: EUR-USDC
+      percentage: "1"
+    },
+    {
+      address: "0x877635e68C1E943D6d6B777C0e847Cd7aE5A01BE", // Jarvis: GBP-USDC
+      percentage: "2"
+    },
+  ]
+
+  async function setupExternalContracts() {
+    miFARM = await IERC20Upgradeable.at(addresses.miFARM);
+    wMATIC = await IERC20Upgradeable.at(addresses.WMATIC);
+  }
+
+  async function setupBalance() {
+    let etherGiver = accounts[9];
+
+    let usdcEur = "0xa832926e3f6a3339ae68f70d76860d212959e0e7";
+    let usdcGbp = "0xe94D89243a7Aeaf88857461ce555caEB344765Fc";
+
+    usdcEurContract = await IERC20Upgradeable.at(usdcEur);
+    usdcGbpContract = await IERC20Upgradeable.at(usdcGbp);
+    await usdcEurContract.transfer(nobody, await usdcEurContract.balanceOf(usdcEurHolder), {from: usdcEurHolder});
+    await usdcGbpContract.transfer(nobody, await usdcGbpContract.balanceOf(usdcGbpHolder), {from: usdcGbpHolder});
+  }
+
+  before(async function() {
+    accounts = await web3.eth.getAccounts();
+    nobody = accounts[7];
+    await setupExternalContracts();
+
+    // impersonate accounts
+    await impersonates([governance, usdcEurHolder, usdcGbpHolder]);
+    await setupBalance();
+
+    // set the governance
+    notifyHelperRegular = await NotifyHelperGeneric.new(storage);
+    statefulHelper = await NotifyHelperStateful.new(storage,
+      notifyHelperRegular.address,
+      addresses.miFARM,
+      notifyHelperRegular.address,
+      "0xFEd53aA679C2C1948473A08202f6203EBDA20FD6",
+      "0xd00FCE4966821Da1EdD1221a02aF0AFc876365e4");
+
+    helperStorage = await Storage.new({from: governance});
+    await notifyHelperRegular.setWhitelist(statefulHelper.address, {from : governance});
+
+    // whitelist generic helper on the pools
+    for (let i = 0; i < emission.length; i++) {
+      let pool = emission[i];
+      let poolContract = await PotPool.at(pool.address);
+      await poolContract.setRewardDistribution([notifyHelperRegular.address], true, {from: governance});
+    }
+
+    globalIncentivesHelper = await GlobalIncentivesHelper.new(storage, addresses.miFARM, statefulHelper.address, notifyHelperRegular.address,
+      "0xFEd53aA679C2C1948473A08202f6203EBDA20FD6",
+      "0xd00FCE4966821Da1EdD1221a02aF0AFc876365e4");
+    await notifyHelperRegular.setWhitelist(globalIncentivesHelper.address, true, {from: governance});
+    await globalIncentivesHelper.newToken(addresses.WMATIC, {from: governance});
+
+    // link the references
+    await statefulHelper.setNotifier(globalIncentivesHelper.address, true, {from: governance});
+    await statefulHelper.setChanger(globalIncentivesHelper.address, true, {from: governance});
+    await globalIncentivesHelper.setChanger(governance, true, {from: governance});
+    await globalIncentivesHelper.setNotifier(governance, true, {from: governance});
+  });
+
+  describe.only("Happy Path with assertions", function() {
+    it("Configure emission for two pot pools", async function() {
+      let tokens = [];
+      let pools = [];
+      let percentages = [];
+      let types = [];
+      let vesting = [];
+      for (let i = 0; i < emission.length; i++) {
+        let pool = emission[i];
+        tokens.push(addresses.miFARM);
+        pools.push(pool.address);
+        percentages.push(pool.percentage);
+        types.push(NotificationType.FARM);
+        vesting.push(false);
+      }
+      for (let i = 0; i < emissionMatic.length; i++) {
+        let pool = emissionMatic[i];
+        tokens.push(addresses.WMATIC);
+        pools.push(pool.address);
+        percentages.push(pool.percentage);
+        types.push(NotificationType.TOKEN);
+        vesting.push(false);
+      }
+      console.log(tokens, pools, percentages, types, vesting);
+      await globalIncentivesHelper.setPoolBatch(tokens, pools, percentages, types, vesting, {from: governance});
+
+      assert.notEqual(
+        await globalIncentivesHelper.tokenToHelper(wMATIC.address),
+        await globalIncentivesHelper.tokenToHelper(miFARM.address)
+      );
+
+      // user nobody stakes
+      let gbpPool = await PotPool.at("0x877635e68C1E943D6d6B777C0e847Cd7aE5A01BE");
+      let eurPool = await PotPool.at("0xf25474FBf9812bE2ef76abf4297A27411C156403");
+      await usdcEurContract.approve(eurPool.address, await usdcEurContract.balanceOf(nobody), {from: nobody});
+      await usdcGbpContract.approve(gbpPool.address, await usdcGbpContract.balanceOf(nobody), {from: nobody});
+      await gbpPool.stake(await usdcGbpContract.balanceOf(nobody), {from: nobody});
+      await eurPool.stake(await usdcEurContract.balanceOf(nobody), {from: nobody});
+
+      await miFARM.transfer(globalIncentivesHelper.address, "50" + "0".repeat(18), {from: governance});
+      await wMATIC.transfer(globalIncentivesHelper.address, "120" + "0".repeat(18), {from: governance});
+      await globalIncentivesHelper.notifyPools([addresses.miFARM, addresses.WMATIC], ["30" + "0".repeat(18), "60" + "0".repeat(18)], "1637694000")
+
+      assert.equal(await miFARM.balanceOf(gbpPool.address), "20" + "0".repeat(18));
+      assert.equal(await wMATIC.balanceOf(gbpPool.address), "40" + "0".repeat(18));
+      assert.equal(await miFARM.balanceOf(eurPool.address), "10" + "0".repeat(18));
+      assert.equal(await wMATIC.balanceOf(eurPool.address), "20" + "0".repeat(18));
+      assert.equal(await miFARM.balanceOf(globalIncentivesHelper.address), "20" + "0".repeat(18));
+      assert.equal(await wMATIC.balanceOf(globalIncentivesHelper.address), "60" + "0".repeat(18));
+
+      assert.notEqual(await gbpPool.rewardRateForToken(miFARM.address), "0");
+      assert.notEqual(await gbpPool.rewardRateForToken(wMATIC.address), "0");
+      assert.notEqual(await eurPool.rewardRateForToken(miFARM.address), "0");
+      assert.notEqual(await eurPool.rewardRateForToken(wMATIC.address), "0");
+
+      // mind blank transactions to increase the time
+      await time.increase(time.duration.days(8));
+      await time.advanceBlock();
+
+//      assert.equal(await gbpPool.earned(miFARM.address, nobody), "20" + "0".repeat(18));
+//      assert.equal(await gbpPool.earned(wMATIC.address, nobody), "40" + "0".repeat(18));
+//      assert.equal(await eurPool.earned(miFARM.address, nobody), "10" + "0".repeat(18));
+//      assert.equal(await eurPool.earned(wMATIC.address, nobody), "20" + "0".repeat(18));
+
+      await gbpPool.exit({from: nobody});
+      await eurPool.exit({from: nobody});
+
+      console.log(new BigNumber(await miFARM.balanceOf(nobody)).toFixed());
+      console.log(new BigNumber(await wMATIC.balanceOf(nobody)).toFixed());
+      assert.equal(await miFARM.balanceOf(nobody), "30" + "0".repeat(18));
+      assert.equal(await wMATIC.balanceOf(nobody), "60" + "0".repeat(18));
+
+    });
+
+  });
+});

package/test/core/emission.js

@@ -0,0 +1,209 @@
+// Utilities
+const Utils = require("../utilities/Utils.js");
+const { impersonates, setupCoreProtocol, depositVault } = require("../utilities/hh-utils.js");
+
+const addresses = require("../../../matic-config/matic-addresses.json");
+const { send, expectRevert, time } = require("@openzeppelin/test-helpers");
+const BigNumber = require("bignumber.js");
+const IERC20Upgradeable = artifacts.require("IERC20Upgradeable");
+
+const Storage = artifacts.require("Storage");
+const NotifyHelperStateful = artifacts.require("NotifyHelperStateful");
+const NotifyHelperGeneric = artifacts.require("NotifyHelperGeneric");
+const GlobalIncentivesHelper = artifacts.require("GlobalIncentivesHelper");
+const Governable = artifacts.require("Governable");
+const Controllable = artifacts.require("Controllable");
+const PotPool = artifacts.require("PotPool");
+
+describe("Emission tests", function() {
+  let accounts;
+
+  let storage = addresses.Storage;
+  let governance = addresses.GOVERNANCE;
+  let bridge = "0x0b2c3d2709900db4a73055c2150d346dd54cb427";
+  let notifyHelperRegular;
+
+  let NotificationType = {
+      VOID : 0, AMPLIFARM : 1, FARM : 2, TRANSFER : 3, PROFIT_SHARE : 4, TOKEN: 5
+  }
+
+  // contracts
+  let miFARM;
+  let statefulHelper;
+  let helperStorage;
+  let globalIncentivesHelper;
+
+  let emission = [
+    {
+      address: addresses.V2.quickswap_IFARM_QUICK.NewPool,
+      percentage: "2"
+    },
+    {
+      address: addresses.V2.quickswap_ETH_USDT.NewPool,
+      percentage: "1"
+    },
+    {
+      address: addresses.V2.sushiswap_USDC_ETH.NewPool,
+      percentage: "2"
+    },
+    {
+      address: addresses.V2.balancer_STABLE.NewPool,
+      percentage: "3"
+    },
+    {
+      address: addresses.V2.balancer_TRICRYPTO.NewPool,
+      percentage: "2"
+    },
+    {
+      address: addresses.V2.balancer_POLYBASE.NewPool,
+      percentage: "3"
+    },
+    {
+      address: addresses.V2.jarvis_AUR_USDC.NewPool,
+      percentage: "2"
+    },
+    {
+      address: addresses.V2.jarvis_JCHF_USDC_HODL.NewPool,
+      percentage: "2"
+    },
+    {
+      address: addresses.V2.jarvis_JEUR_USDC_HODL.NewPool,
+      percentage: "2"
+    },
+    {
+      address: addresses.V2.jarvis_JGBP_USDC_HODL.NewPool,
+      percentage: "2"
+    },
+
+  ]
+  let emissionMatic = [
+      {
+        address: addresses.V2.balancer_STABLE.NewPool,
+        percentage: "3"
+      },
+      {
+        address: addresses.V2.balancer_TRICRYPTO.NewPool,
+        percentage: "2"
+      },
+      {
+        address: addresses.V2.balancer_POLYBASE.NewPool,
+        percentage: "3"
+      },
+      {
+        address: addresses.V2.jarvis_AUR_USDC.NewPool,
+        percentage: "2"
+      },
+      {
+        address: addresses.V2.jarvis_JCHF_USDC_HODL.NewPool,
+        percentage: "2"
+      },
+      {
+        address: addresses.V2.jarvis_JEUR_USDC_HODL.NewPool,
+        percentage: "2"
+      },
+      {
+        address: addresses.V2.jarvis_JGBP_USDC_HODL.NewPool,
+        percentage: "2"
+      },
+
+    ]
+
+  async function setupExternalContracts() {
+    miFARM = await IERC20Upgradeable.at(addresses.miFARM);
+    wMATIC = await IERC20Upgradeable.at(addresses.WMATIC);
+  }
+
+  async function setupBalance() {
+    let etherGiver = accounts[9];
+    // Give whale some ether to make sure the following actions are good
+    await send.ether(etherGiver, underlyingWhale, "1" + "000000000000000000");
+    await send.ether(etherGiver, bridge, "1" + "000000000000000000");
+
+    farmerBalance = "1000" + "0".repeat(6);
+    await underlying.transfer(farmer, farmerBalance, {from: underlyingWhale});
+  }
+
+  before(async function() {
+    accounts = await web3.eth.getAccounts();
+    let nobody = accounts[7];
+    await setupExternalContracts();
+    await send.ether(nobody, bridge, "1" + "000000000000000000");
+
+    // impersonate accounts
+    await impersonates([governance, bridge]);
+
+    // set the governance
+    notifyHelperRegular = await NotifyHelperGeneric.new(storage);
+    statefulHelper = await NotifyHelperStateful.new(storage,
+      notifyHelperRegular.address,
+      addresses.miFARM,
+      notifyHelperRegular.address,
+      "0xFEd53aA679C2C1948473A08202f6203EBDA20FD6",
+      "0xd00FCE4966821Da1EdD1221a02aF0AFc876365e4");
+
+    helperStorage = await Storage.new({from: governance});
+    await notifyHelperRegular.setWhitelist(statefulHelper.address, {from : governance});
+
+    // whitelist generic helper on the pools
+    for (let i = 0; i < emission.length; i++) {
+      let pool = emission[i];
+      let poolContract = await PotPool.at(pool.address);
+      await poolContract.setRewardDistribution([notifyHelperRegular.address], true, {from: governance});
+    }
+
+    globalIncentivesHelper = await GlobalIncentivesHelper.new(storage, addresses.miFARM, statefulHelper.address, notifyHelperRegular.address,
+      "0xFEd53aA679C2C1948473A08202f6203EBDA20FD6",
+      "0xd00FCE4966821Da1EdD1221a02aF0AFc876365e4");
+    await notifyHelperRegular.setWhitelist(globalIncentivesHelper.address, true, {from: governance});
+    await globalIncentivesHelper.newToken(addresses.WMATIC, {from: governance});
+
+    // link the references
+    await statefulHelper.setNotifier(globalIncentivesHelper.address, true, {from: governance});
+    await statefulHelper.setChanger(globalIncentivesHelper.address, true, {from: governance});
+    await globalIncentivesHelper.setChanger(governance, true, {from: governance});
+    await globalIncentivesHelper.setNotifier(governance, true, {from: governance});
+  });
+
+  describe.only("Happy Path with math", function() {
+    it("Configure emission", async function() {
+      let tokens = [];
+      let pools = [];
+      let percentages = [];
+      let types = [];
+      let vesting = [];
+      for (let i = 0; i < emission.length; i++) {
+        let pool = emission[i];
+        tokens.push(addresses.miFARM);
+        pools.push(pool.address);
+        percentages.push(pool.percentage);
+        types.push(NotificationType.FARM);
+        vesting.push(false);
+      }
+      for (let i = 0; i < emissionMatic.length; i++) {
+        let pool = emissionMatic[i];
+        tokens.push(addresses.WMATIC);
+        pools.push(pool.address);
+        percentages.push(pool.percentage);
+        types.push(NotificationType.TOKEN);
+        vesting.push(false);
+      }
+      console.log(tokens, pools, percentages, types, vesting);
+      await globalIncentivesHelper.setPoolBatch(tokens, pools, percentages, types, vesting, {from: governance});
+
+      let config = await statefulHelper.getConfig("50" + "0".repeat(18));
+      for (let i = 0; i < config[0].length; i++) {
+        console.log(config[0][i]);
+        console.log(config[1][i].toString());
+        console.log(config[2][i].toString());
+        console.log("");
+      }
+
+      await miFARM.approve(globalIncentivesHelper.address, "50" + "0".repeat(18), {from: governance});
+      await miFARM.transfer(governance, "50" + "0".repeat(18), {from: bridge});
+      await wMATIC.approve(globalIncentivesHelper.address, "50" + "0".repeat(18), {from: governance});
+      await globalIncentivesHelper.notifyPools([addresses.miFARM, addresses.WMATIC], ["50" + "0".repeat(18), "50" + "0".repeat(18)], "1637694000")
+
+    });
+
+  });
+});

package/test/core/vault_upgrade.js

@@ -0,0 +1,129 @@
+// 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("IERC20");
+
+//const Strategy = artifacts.require("");
+const Strategy = artifacts.require("AuraStrategyMainnet_jEUR_PAR");
+const VaultProxyContract = artifacts.require("VaultProxy");
+const VaultImplContract = artifacts.require("VaultERC4626");
+
+// Developed and tested at blockNumber 51325000
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Polygon Mainnet Balancer 2EUR PAR", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let underlyingWhale = "0xD927cE147f098cE634301e6c4281541b1939a132";
+
+  // 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("0x513CdEE00251F39DE280d9E5f771A6eaFebCc88E");
+    console.log("Fetching Underlying at: ", underlying.address);
+  }
+
+  async function setupBalance(){
+    let etherGiver = accounts[9];
+    await web3.eth.sendTransaction({ from: etherGiver, to: underlyingWhale, 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]);
+
+    let etherGiver = accounts[9];
+    await web3.eth.sendTransaction({ from: etherGiver, to: governance, value: 100e18});
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": "0x41f36BB5B26F2E8646E6ADC97FAA5E2844a6c842",
+      "announceStrategy": true,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+    });
+    const newImpl = await VaultImplContract.new()
+    await vault.scheduleUpgrade(newImpl.address, {from: governance});
+    await Utils.waitHours(13);
+    const vaultProxy = await VaultProxyContract.at(vault.address);
+    await vaultProxy.upgrade({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
+      let hours = 10;
+      let blocksPerHour = 1565*5;
+      let oldSharePrice;
+      let newSharePrice;
+      for (let i = 0; i < hours; i++) {
+        console.log("loop ", i);
+        vault.withdraw(farmerOldBalance.div(10), {from: farmer1})
+        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(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/1565))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/1565))+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
+
+    });
+  });
+});