@harvest-finance/harvest-strategy-arbitrum 0.0.1-security → 1.0.1

package/test/notional/nusdt.js

@@ -0,0 +1,133 @@
+// 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("NotionalStrategyMainnet_nUSDT");
+
+//This test was developed at blockNumber 252737900
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Mainnet Notional nUSDT", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let underlyingWhale = "0xbdE30e219d605E202237564c6D93FA5171788bdc";
+  let note = "0x019bE259BC299F3F653688c7655C87F998Bc7bC1";
+  let weth = "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1";
+  let arb = "0x912CE59144191C1204E64559FE8253a0e49E6548";
+
+  // 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("0x9c0Fbb8caDE7B178b135fD2F1da125a37B27f442");
+    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: 10e18});
+    await web3.eth.sendTransaction({ from: etherGiver, to: addresses.ULOwner, value: 10e18});
+
+    farmerBalance = await underlying.balanceOf(underlyingWhale);
+    await underlying.transfer(farmer1, farmerBalance, { from: underlyingWhale });
+  }
+
+  before(async function() {
+    governance = addresses.Governance;
+    accounts = await web3.eth.getAccounts();
+
+    await web3.eth.sendTransaction({ from: accounts[8], to: governance, value: 10e18});
+    await web3.eth.sendTransaction({ from: accounts[8], to: addresses.ULOwner, value: 10e18});
+
+    farmer1 = accounts[1];
+
+    // impersonate accounts
+    await impersonates([governance, underlyingWhale, addresses.ULOwner]);
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+      "liquidation": [
+        {"uniV3": [note, weth]},
+        {"camelot": [arb, weth]},
+        {"uniV3": [weth, note]}
+      ],
+      "uniV3Fee": [
+        [note, weth, 10000]
+      ],
+      "ULOwner": addresses.ULOwner
+    });
+
+    // 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);
+      let fTokenBalance = new BigNumber(await vault.balanceOf(farmer1));
+
+      // Using half days is to simulate how we doHardwork in the real world
+      let hours = 10;
+      let blocksPerHour = 2400;
+      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/300))*365;
+        apy = ((newSharePrice.toFixed()/oldSharePrice.toFixed()-1)*(24/(blocksPerHour/300))+1)**365;
+
+        console.log("instant APR:", apr*100, "%");
+        console.log("instant APY:", (apy-1)*100, "%");
+        await vault.withdraw(fTokenBalance.div(10), { from: farmer1 });
+        await depositVault(farmer1, underlying, vault, new BigNumber(await underlying.balanceOf(farmer1)))
+        await Utils.advanceNBlock(blocksPerHour);
+      }
+      fTokenBalance = new BigNumber(await vault.balanceOf(farmer1));
+      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/300))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/300))+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
+    });
+  });
+});

package/test/notional/nwsteth.js

@@ -0,0 +1,133 @@
+// 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("NotionalStrategyMainnet_nwstETH");
+
+//This test was developed at blockNumber 252737900
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Mainnet Notional nwstETH", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let underlyingWhale = "0x4Ee711b72b476f47A05AEc5a260BA42Bb564404D";
+  let note = "0x019bE259BC299F3F653688c7655C87F998Bc7bC1";
+  let weth = "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1";
+  let arb = "0x912CE59144191C1204E64559FE8253a0e49E6548";
+
+  // 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("0x06D45ef1f8b3C37b0de66f156B11F10b4837619A");
+    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: 10e18});
+    await web3.eth.sendTransaction({ from: etherGiver, to: addresses.ULOwner, value: 10e18});
+
+    farmerBalance = await underlying.balanceOf(underlyingWhale);
+    await underlying.transfer(farmer1, farmerBalance, { from: underlyingWhale });
+  }
+
+  before(async function() {
+    governance = addresses.Governance;
+    accounts = await web3.eth.getAccounts();
+
+    await web3.eth.sendTransaction({ from: accounts[8], to: governance, value: 10e18});
+    await web3.eth.sendTransaction({ from: accounts[8], to: addresses.ULOwner, value: 10e18});
+
+    farmer1 = accounts[1];
+
+    // impersonate accounts
+    await impersonates([governance, underlyingWhale, addresses.ULOwner]);
+
+    await setupExternalContracts();
+    [controller, vault, strategy] = await setupCoreProtocol({
+      "existingVaultAddress": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+      "liquidation": [
+        {"uniV3": [note, weth]},
+        {"camelot": [arb, weth]},
+        {"uniV3": [weth, note]}
+      ],
+      "uniV3Fee": [
+        [note, weth, 10000]
+      ],
+      "ULOwner": addresses.ULOwner
+    });
+
+    // 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);
+      let fTokenBalance = new BigNumber(await vault.balanceOf(farmer1));
+
+      // Using half days is to simulate how we doHardwork in the real world
+      let hours = 10;
+      let blocksPerHour = 2400;
+      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/300))*365;
+        apy = ((newSharePrice.toFixed()/oldSharePrice.toFixed()-1)*(24/(blocksPerHour/300))+1)**365;
+
+        console.log("instant APR:", apr*100, "%");
+        console.log("instant APY:", (apy-1)*100, "%");
+        await vault.withdraw(fTokenBalance.div(10), { from: farmer1 });
+        await depositVault(farmer1, underlying, vault, new BigNumber(await underlying.balanceOf(farmer1)))
+        await Utils.advanceNBlock(blocksPerHour);
+      }
+      fTokenBalance = new BigNumber(await vault.balanceOf(farmer1));
+      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/300))*365;
+      apy = ((farmerNewBalance.toFixed()/farmerOldBalance.toFixed()-1)*(24/(blocksPerHour*hours/300))+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
+    });
+  });
+});

package/test/test-config.js

@@ -0,0 +1,28 @@
+module.exports = {
+  "Storage": "0x88937abfc8C6A88cc70bfc686E4fBba80DE8d329",
+  "RewardForwarder": "0xC5a1873Bb6F83C677EB255194562500CcB7eE67F",
+  "UniversalLiquidator": "0x5f513cA572e7eD10487cEF2b0636C07eA9b82AD8",
+  "UniversalLiquidatorRegistry": "0xbcE9d31FfA2c96E11cEbEAa021136a83A3575D95",
+  "ULOwner": "0x6a74649aCFD7822ae8Fb78463a9f2192752E5Aa2",
+  "Controller": "0x68B2FC1566f411C1Af8fF5bFDA3dD4F3F3e59D03",
+  "Governance": "0xF066789028fE31D4f53B69B81b328B8218Cc0641",
+  "iFARM": "0x9dCA587dc65AC0a043828B0acd946d71eb8D46c1",
+  "WETH": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+  "VaultImplementationV2": "0x350856A672e7bF7D7327c8a5e72Ac49833DBfB75",
+  "CommunityMsig": "0xf3D1A027E858976634F81B7c41B09A05A46EdA21",
+  "ProfitShare": "0x5F11EfDF4422B548007Cae9919b0b38c35fa6BE7",
+  "Reader": "0xD5E42f45CC4ef59dE83999FAAd1bef25A7abf657",
+  "Incentives": {
+    "GlobalIncentivesExecutor": "0x9d052Ab5344F6D0a5dcf685D42906f48E6F2beaF",
+    "GlobalIncentivesHelper": "0x8F0d40c95047c6B09f08905C110d002E65e96C7d",
+    "NotifyHelperGeneric": "0xC0cE53f755feAe93Fd219b2Cd0F58a4Fd0d535Dd",
+    "NotifyHelperStateful": "0x99AFf7327CEb88fE408d1fB93dc3150fEa5f9A2A",
+    "ViewerNotifyHelperStateful": "0xb93280253E93d9CF01FbE500981792E1c577607d",
+  },
+  "Factory": {
+    "VaultFactory": "0x61d568C11321d12E05959203f00F19E4bd628122",
+    "PotPoolFactory": "0xB1E448117dF310b6090477291E57198A0b1816a8",
+    "MegaFactory": "0x344aECFdB8894E82178Bc45CE35ff7741b6aA527",
+    "UpgradableStrategyFactory": "0x9d8265676080489D68482B106620b0b7ED463EA0"
+  }
+};

package/test/utilities/Utils.js

@@ -0,0 +1,96 @@
+const BigNumber = require('bignumber.js');
+const { time } = require("@openzeppelin/test-helpers");
+BigNumber.config({DECIMAL_PLACES: 0});
+
+let gasLogger = {};
+let gasLoggerNum = {};
+
+async function gasLog(logTo, targetPromise) {
+  let tx = await targetPromise;
+  gasUsed = tx.receipt.gasUsed;
+
+  if(gasLogger[logTo] == undefined) {
+    gasLogger[logTo] = gasUsed;
+    gasLoggerNum[logTo] = 1;
+  }
+  else {
+    gasLogger[logTo] = (gasLogger[logTo])/(gasLoggerNum[logTo]+1) + gasUsed/(gasLoggerNum[logTo]+1);
+    gasLoggerNum[logTo]++;
+  }
+}
+
+async function printGasLog() {
+  console.log(gasLogger);
+}
+
+async function advanceNBlock (n) {
+  let startingBlock = await time.latestBlock();
+  await time.increase(12 * Math.round(n));
+  let endBlock = startingBlock.addn(n);
+  await time.advanceBlockTo(endBlock);
+}
+async function waitHours (n) {
+  await time.increase(n * 3600 + 1);
+  let startingBlock = await time.latestBlock();
+  await time.advanceBlockTo(startingBlock.addn(1));
+};
+
+async function waitTime (n) {
+  await time.increase(n);
+  let startingBlock = await time.latestBlock();
+  await time.advanceBlockTo(startingBlock.addn(1));
+};
+
+function assertBNEq(a, b){
+  let _a = new BigNumber(a);
+  let _b = new BigNumber(b);
+  let msg = _a.toFixed() + " != " + _b.toFixed();
+  assert.equal(_a.eq(_b), true, msg);
+}
+
+function assertApproxBNEq(a, b, c){
+  let _a = new BigNumber(a).div(c);
+  let _b = new BigNumber(b).div(c);
+  let msg = _a.toFixed() + " != " + _b.toFixed();
+  assert.equal(_a.eq(_b), true, msg);
+}
+
+function assertBNGt(a, b){
+  let _a = new BigNumber(a);
+  let _b = new BigNumber(b);
+  let msg = _a.toFixed() + " is not greater than " + _b.toFixed();
+  assert.equal(_a.gt(_b), true, msg);
+}
+
+function assertBNGte(a, b){
+  let _a = new BigNumber(a);
+  let _b = new BigNumber(b);
+  let msg = _a.toFixed() + " is not greater than " + _b.toFixed();
+  assert.equal(_a.gte(_b), true, msg);
+}
+
+function assertNEqBN(a, b){
+  let _a = new BigNumber(a);
+  let _b = new BigNumber(b);
+  assert.equal(_a.eq(_b), false);
+}
+
+async function inBNfixed(a) {
+  return await (new BigNumber(a)).toFixed();
+}
+
+module.exports = {
+  gasLogger,
+  gasLoggerNum,
+  gasLog,
+  printGasLog,
+  advanceNBlock,
+  assertBNEq,
+  assertApproxBNEq,
+  assertBNGt,
+  assertNEqBN,
+  inBNfixed,
+  waitHours,
+  waitTime,
+  assertBNGte,
+};

package/test/utilities/hh-utils.js

@@ -0,0 +1,248 @@
+const makeVault = require("./make-vault.js");
+const addresses = require("../test-config.js");
+const IController = artifacts.require("IController");
+const IRewardForwarder = artifacts.require("IRewardForwarder");
+const Vault = artifacts.require("VaultV2");
+const GMXVault = artifacts.require("VaultV2GMX");
+const IUpgradeableStrategy = artifacts.require("IUpgradeableStrategy");
+const ILiquidatorRegistry = artifacts.require("IUniversalLiquidatorRegistry");
+const IDex = artifacts.require("IDex");
+const IBalDex = artifacts.require("IBalDex");
+
+const Utils = require("./Utils.js");
+
+async function impersonates(targetAccounts){
+  console.log("Impersonating...");
+  for(i = 0; i < targetAccounts.length ; i++){
+    console.log(targetAccounts[i]);
+    await hre.network.provider.request({
+      method: "hardhat_impersonateAccount",
+      params: [
+        targetAccounts[i]
+      ]
+    });
+  }
+}
+
+async function setupCoreProtocol(config) {
+  // Set vault (or Deploy new vault), underlying, underlying Whale,
+  // amount the underlying whale should send to farmers
+  if(config.existingVaultAddress != null){
+    vault = await Vault.at(config.existingVaultAddress);
+    console.log("Fetching Vault at: ", vault.address);
+  } else {
+    let implAddress, useGMX
+    if (config.useGMXVault) {
+      vaultImpl = await GMXVault.new();
+      implAddress = vaultImpl.address;
+      useGMX = true;
+    } else {
+      implAddress = config.vaultImplementationOverride || addresses.VaultImplementationV2;
+      useGMX = false;
+    }
+    vault = await makeVault(implAddress, useGMX, addresses.Storage, config.underlying.address, 100, 100, {
+      from: config.governance,
+    });
+    console.log("New Vault Deployed: ", vault.address);
+  }
+
+  controller = await IController.at(addresses.Controller);
+  feeRewardForwarder = await IRewardForwarder.at(await controller.rewardForwarder());
+
+
+  if (config.feeRewardForwarder) {/*
+    const FeeRewardForwarder = artifacts.require("FeeRewardForwarder");
+    const feeRewardForwarder = await FeeRewardForwarder.new(
+      addresses.Storage,
+      addresses.FARM,
+      addresses.miFARM,
+      addresses.UniversalLiquidatorRegistry
+    );
+
+    config.feeRewardForwarder = feeRewardForwarder.address;*/
+    console.log("Setting up a custom fee reward forwarder...");
+    await controller.setRewardForwarder(
+      config.feeRewardForwarder,
+      { from: config.governance }
+    );
+
+    const NoMintRewardPool = artifacts.require("NoMintRewardPool");
+    const farmRewardPool = await NoMintRewardPool.at("0x8f5adC58b32D4e5Ca02EAC0E293D35855999436C");
+    await farmRewardPool.setRewardDistribution(config.feeRewardForwarder, {from: config.governance});
+
+    console.log("Done setting up fee reward forwarder!");
+  }
+
+  let rewardPool = null;
+
+  if (!config.rewardPoolConfig) {
+    config.rewardPoolConfig = {};
+  }
+  // if reward pool is required, then deploy it
+  if(config.rewardPool != null && config.existingRewardPoolAddress == null) {
+    const rewardTokens = config.rewardPoolConfig.rewardTokens || [addresses.FARM];
+    const rewardDistributions = [config.governance];
+    if (config.feeRewardForwarder) {
+      rewardDistributions.push(config.feeRewardForwarder);
+    }
+
+    if (config.rewardPoolConfig.type === 'PotPool') {
+      const PotPool = artifacts.require("PotPool");
+      console.log("reward pool needs to be deployed");
+      rewardPool = await PotPool.new(
+        rewardTokens,
+        vault.address,
+        64800,
+        rewardDistributions,
+        addresses.Storage,
+        "fPool",
+        "fPool",
+        18,
+        {from: config.governance }
+      );
+      console.log("New PotPool deployed: ", rewardPool.address);
+    } else {
+      const NoMintRewardPool = artifacts.require("NoMintRewardPool");
+      console.log("reward pool needs to be deployed");
+      rewardPool = await NoMintRewardPool.new(
+        rewardTokens[0],
+        vault.address,
+        64800,
+        rewardDistributions,
+        addresses.Storage,
+        "0x0000000000000000000000000000000000000000",
+        "0x0000000000000000000000000000000000000000",
+        {from: config.governance }
+      );
+      console.log("New NoMintRewardPool deployed: ", rewardPool.address);
+    }
+  } else if(config.existingRewardPoolAddress != null) {
+    const PotPool = artifacts.require("PotPool");
+    rewardPool = await PotPool.at(config.existingRewardPoolAddress);
+    console.log("Fetching Reward Pool deployed: ", rewardPool.address);
+  }
+
+  let universalLiquidatorRegistry = await ILiquidatorRegistry.at(addresses.UniversalLiquidatorRegistry);
+
+  // set liquidation paths
+  if(config.liquidation) {
+    for (i=0;i<config.liquidation.length;i++) {
+      dex = Object.keys(config.liquidation[i])[0];
+      await universalLiquidatorRegistry.setPath(
+        web3.utils.keccak256(dex),
+        config.liquidation[i][dex],
+        {from: config.ULOwner}
+      );
+    }
+  }
+
+  if(config.uniV3Fee) {
+    const uniV3Dex = await IDex.at("0x357F2E6Cd64A1fD4525e4eC22d7635115C9Ca3cb");
+    for (i=0;i<config.uniV3Fee.length;i++) {
+      await uniV3Dex.setFee(config.uniV3Fee[i][0], config.uniV3Fee[i][1], config.uniV3Fee[i][2], {from: config.ULOwner})
+    }
+  }
+  if(config.pancakeV3Fee) {
+    const uniV3Dex = await IDex.at("0x7F60C26a34D2B9D99D8DeFD321C32fd717bEB8A5");
+    for (i=0;i<config.pancakeV3Fee.length;i++) {
+      await uniV3Dex.setFee(config.pancakeV3Fee[i][0], config.pancakeV3Fee[i][1], config.pancakeV3Fee[i][2], {from: config.ULOwner})
+    }
+  }
+  if(config.curveSetup) {
+    const curveDex = await IDex.at("0xdeb935422497c8bD46B84e066c742d3A21BEe06b");
+    for (i=0;i<config.curveSetup.length;i++) {
+      await curveDex.pairSetup(config.curveSetup[i][0], config.curveSetup[i][1], config.curveSetup[i][2], config.curveSetup[i][3], {from: config.ULOwner})
+    }
+  }
+  if(config.balancerPool) {
+    const dex = await IBalDex.at("0x48aC1856D6B96ae9F29107a3A0Be825BFEF58014");
+    for (i=0;i<config.balancerPool.length;i++) {
+      await dex.setPool(config.balancerPool[i][0], config.balancerPool[i][1], config.balancerPool[i][2], {from: config.ULOwner})
+    }
+  }
+
+  // default arguments are storage and vault addresses
+  config.strategyArgs = config.strategyArgs || [
+    addresses.Storage,
+    vault.address
+  ];
+
+  for(i = 0; i < config.strategyArgs.length ; i++){
+    if(config.strategyArgs[i] == "storageAddr") {
+      config.strategyArgs[i] = addresses.Storage;
+    } else if(config.strategyArgs[i] == "vaultAddr") {
+      config.strategyArgs[i] = vault.address;
+    } else if(config.strategyArgs[i] == "poolAddr" ){
+      config.strategyArgs[i] = rewardPool.address;
+    } else if(config.strategyArgs[i] == "universalLiquidatorRegistryAddr"){
+      config.strategyArgs[i] = universalLiquidatorRegistry.address;
+    }
+  }
+
+  let strategyImpl = null;
+
+  if (!config.strategyArtifactIsUpgradable) {
+    strategy = await config.strategyArtifact.new(
+      ...config.strategyArgs,
+      { from: config.governance }
+    );
+  } else {
+    strategyImpl = await config.strategyArtifact.new();
+    const StrategyProxy = artifacts.require("StrategyProxy");
+
+    const strategyProxy = await StrategyProxy.new(strategyImpl.address);
+    strategy = await config.strategyArtifact.at(strategyProxy.address);
+    await strategy.initializeStrategy(
+      ...config.strategyArgs,
+      { from: config.governance }
+    );
+  }
+
+  console.log("Strategy Deployed: ", strategy.address);
+
+  if (config.liquidationPath) {
+    const path = config.liquidationPath.path;
+    const router = addresses[config.liquidationPath.router];
+    await feeRewardForwarder.setConversionPath(
+      path[0],
+      path[path.length - 1],
+      path,
+      router,
+      {from: config.governance}
+    );
+  }
+
+  if (config.announceStrategy === true) {
+    // Announce switch, time pass, switch to strategy
+    await vault.announceStrategyUpdate(strategy.address, { from: config.governance });
+    console.log("Strategy switch announced. Waiting...");
+    await Utils.waitHours(13);
+    await vault.setStrategy(strategy.address, { from: config.governance });
+    await vault.setVaultFractionToInvest(100, 100, { from: config.governance });
+    console.log("Strategy switch completed.");
+  } else if (config.upgradeStrategy === true) {
+    // Announce upgrade, time pass, upgrade the strategy
+    const strategyAsUpgradable = await IUpgradeableStrategy.at(await vault.strategy());
+    await strategyAsUpgradable.scheduleUpgrade(strategyImpl.address, { from: config.governance });
+    console.log("Upgrade scheduled. Waiting...");
+    await Utils.waitHours(13);
+    await strategyAsUpgradable.upgrade({ from: config.governance });
+    await vault.setVaultFractionToInvest(100, 100, { from: config.governance });
+    strategy = await config.strategyArtifact.at(await vault.strategy());
+    console.log("Strategy upgrade completed.");
+  } else {
+    await vault.setStrategy(strategy.address, {from: config.governance});
+  }
+  return [controller, vault, strategy, rewardPool];
+}
+
+async function depositVault(_farmer, _underlying, _vault, _amount) {
+  await _underlying.approve(_vault.address, _amount, { from: _farmer });
+  await _vault.deposit(_amount, _farmer, { from: _farmer });
+}
+
+module.exports = {
+  impersonates,
+  setupCoreProtocol,
+  depositVault
+};

package/test/utilities/make-vault.js

@@ -0,0 +1,16 @@
+const Vault = artifacts.require("VaultV2");
+const GMXVault = artifacts.require("VaultV2GMX");
+const VaultProxy = artifacts.require("VaultProxy");
+
+module.exports = async function(implementationAddress, useGMX, ...args) {
+  const fromParameter = args[args.length - 1]; // corresponds to {from: governance}
+  const vaultAsProxy = await VaultProxy.new(implementationAddress, fromParameter);
+  let vault
+  if (useGMX) {
+    vault = await GMXVault.at(vaultAsProxy.address);
+  } else {
+    vault = await Vault.at(vaultAsProxy.address)
+  }
+  await vault.initializeVault(...args);
+  return vault;
+};