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

package/scripts/README.md

@@ -0,0 +1,55 @@
+# Factory Scripts
+
+The scripts allow for a whitelisted party to deploy components of Harvest, such as vaults, pools, and strategies.
+Important:
+1. Set gas limit to VERY high (~9,000,000)
+2. Deployments are pretty expensive: please make sure there is enough Ether (1 ETH, or more for one deployment).
+3. Always simulate the transaction first by appending the flag `--network hardhat` (or omitting `--network`)
+4. Once simulation is successful, use the mainnet flag: `--network mainnet`
+5. Take prerequisites into account (such as, creating a position token for Uniswap V3)
+
+Latest factory addresses are located in `./test/test-config.js`, under `Factory`.
+
+### Regular vault (with upgradable strategy)
+
+Deploying a new vault with the standard reward PotPool, using an upgradable strategy implementation (that was deployed earlier):
+
+```
+npx hardhat run ./scripts/01-deploy-vault-regular-with-upgradable-strategy.js --network hardhat
+Regular vault deployment with upgradable strategy.
+> Prerequisite: deploy upgradable strategy implementation
+Specify a unique ID (for the JSON), vault's underlying token address, and upgradable strategy implementation address
+prompt: id:  test_YEL_WETH
+prompt: underlying:  0xc83cE8612164eF7A13d17DDea4271DD8e8EEbE5d
+prompt: strategyImpl:  0xBa6b43ae8Ea74a5D7F4e65904aAf80bFB1Bc59CB
+======
+test_YEL_WETH: {
+  "Underlying": "0xc83cE8612164eF7A13d17DDea4271DD8e8EEbE5d",
+  "NewVault": "0xd1c9CE4C3D87B2B9dDc500F6f47E65FB7d426Ac2",
+  "NewStrategy": "0x908B743A405F23Ea5877C14E32d76B1B7A97369D",
+  "NewPool": "0x9b2C5A51adac687867C19Bd76656702b47A24e16"
+}
+======
+Deployment complete. Add the JSON above to `harvest-api` (https://github.com/harvest-finance/harvest-api/blob/master/data/mainnet/addresses.json) repo and add entries to `tokens.js` and `pools.js`.
+```
+
+### Regular vault (no strategy)
+
+Deploying a regular vault with the standard reward PotPool (no pre-defined strategy, but can be added later by Governance):
+
+```
+npx hardhat run ./scripts/02-deploy-vault-regular.js --network hardhat
+Regular vault deployment (no strategy).
+Specify a unique ID (for the JSON) and the vault's underlying token address
+prompt: id:  dai_test
+prompt: underlying:  0x6B175474E89094C44Da98b954EedeAC495271d0F
+======
+dai_test: {
+  "Underlying": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+  "NewVault": "0xd1c9CE4C3D87B2B9dDc500F6f47E65FB7d426Ac2",
+  "NewStrategy": "0x0000000000000000000000000000000000000000",
+  "NewPool": "0x9b2C5A51adac687867C19Bd76656702b47A24e16"
+}
+======
+Deployment complete. Add the JSON above to `harvest-api` (https://github.com/harvest-finance/harvest-api/blob/master/data/mainnet/addresses.json) repo and add entries to `tokens.js` and `pools.js`.
+```

package/scripts/utils.js

@@ -0,0 +1,42 @@
+async function getFeeData() {
+  const feeData = await ethers.provider.getFeeData();
+  feeData.maxPriorityFeePerGas = 35e9;
+  if (feeData.maxFeePerGas < feeData.maxPriorityFeePerGas) {
+    feeData.maxFeePerGas = Number(feeData.maxFeePerGas) + Number(feeData.maxPriorityFeePerGas);
+  }
+  if (feeData.maxFeePerGas > 1000e9) {
+    feeData.maxFeePerGas = 1000e9;
+  }
+  if (feeData.maxFeePerGas / 6 > 35e9) {
+    feeData.maxPriorityFeePerGas = Math.round(feeData.maxFeePerGas / 6);
+    if (feeData.maxPriorityFeePerGas > 100e9) {
+      feeData.maxPriorityFeePerGas = 100e9;
+    }
+  }
+  return feeData;
+}
+
+async function getSigner() {
+  const signer = await ethers.provider.getSigner();
+  return signer;
+}
+
+async function type2Transaction(callFunction, ...params) {
+  const signer = await getSigner();
+  const feeData = await getFeeData();
+  const unsignedTx = await callFunction.request(...params);
+  const tx = await signer.sendTransaction({
+    from: unsignedTx.from,
+    to: unsignedTx.to,
+    data: unsignedTx.data,
+    maxFeePerGas: feeData.maxFeePerGas,
+    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
+    gasLimit: 5e6
+  });
+  await tx.wait();
+  return tx;
+}
+
+module.exports = {
+  type2Transaction,
+};

package/test/aave/dai.js

@@ -0,0 +1,207 @@
+// 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("AaveSupplyStrategyMainnet_DAI");
+
+//This test was developed at blockNumber 54064600
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Mainnet Aave DAI", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let underlyingWhale = "0x2728E3Bd1fd2065D02fC9F87803F31eBaD32b32C";
+  let usdce = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+  let weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+  let eurs = "0xE111178A87A3BFf0c8d18DECBa5798827539Ae99";
+
+  // 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("0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063");
+    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});
+
+    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": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+      "liquidation": [
+        {"uniV3": [underlying.address, weth]},
+        {"uniV3": [underlying.address, weth, addresses.miFARM]},
+      ],
+    });
+
+    // 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);
+
+        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);
+    });
+  });
+
+});

package/test/aave/eurs.js

@@ -0,0 +1,207 @@
+// 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("AaveSupplyStrategyMainnet_EURS");
+
+//This test was developed at blockNumber 54064600
+
+// Vanilla Mocha test. Increased compatibility with tools that integrate Mocha.
+describe("Mainnet Aave EURS", function() {
+  let accounts;
+
+  // external contracts
+  let underlying;
+
+  // external setup
+  let underlyingWhale = "0x95E49B7a5a7aD75f0cd904f8f2329128025d9d2a";
+  let usdce = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
+  let weth = "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619";
+  let eurs = "0xE111178A87A3BFf0c8d18DECBa5798827539Ae99";
+
+  // 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("0xE111178A87A3BFf0c8d18DECBa5798827539Ae99");
+    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});
+
+    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": null,
+      "strategyArtifact": Strategy,
+      "strategyArtifactIsUpgradable": true,
+      "underlying": underlying,
+      "governance": governance,
+      "liquidation": [
+        {"uniV3": [eurs, usdce, weth]},
+        {"uniV3": [eurs, usdce, weth, addresses.miFARM]},
+      ],
+    });
+
+    // 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);
+
+        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);
+    });
+  });
+
+});