Convex frxETH/WETH strategy

contracts/contracts/harvest/Harvester.sol

@@ -7,11 +7,9 @@ import { SafeMath } from "@openzeppelin/contracts/utils/math/SafeMath.sol";
 import "@openzeppelin/contracts/utils/math/Math.sol";
 
 import { StableMath } from "../utils/StableMath.sol";
-import { Governable } from "../governance/Governable.sol";
 import { IVault } from "../interfaces/IVault.sol";
 import { IOracle } from "../interfaces/IOracle.sol";
 import { BaseHarvester } from "./BaseHarvester.sol";
-import { IStrategy } from "../interfaces/IStrategy.sol";
 import { IUniswapV2Router } from "../interfaces/uniswap/IUniswapV2Router02.sol";
 import "../utils/Helpers.sol";
 

contracts/contracts/harvest/OETHHarvester.sol

@@ -7,11 +7,9 @@ import { SafeMath } from "@openzeppelin/contracts/utils/math/SafeMath.sol";
 import "@openzeppelin/contracts/utils/math/Math.sol";
 
 import { StableMath } from "../utils/StableMath.sol";
-import { Governable } from "../governance/Governable.sol";
 import { IVault } from "../interfaces/IVault.sol";
 import { IOracle } from "../interfaces/IOracle.sol";
 import { BaseHarvester } from "./BaseHarvester.sol";
-import { IStrategy } from "../interfaces/IStrategy.sol";
 import { IUniswapV2Router } from "../interfaces/uniswap/IUniswapV2Router02.sol";
 import "../utils/Helpers.sol";
 

contracts/contracts/mocks/MockMetadataToken.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// IERC20Metadata is used in the resolveAsset function in contracts/utils/assets.js
+// We just need to import it here to make its ABI available to Hardhat
+import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";

contracts/contracts/mocks/MocksfrxETH.sol

@@ -57,11 +57,11 @@ contract MocksfrxETH is MintableERC20 {
         address receiver,
         address owner
     ) external returns (uint256 shares) {
-        _burn(owner, shares);
+        _burn(owner, assets);
 
-        ERC20(frxETH).transfer(receiver, shares);
+        ERC20(frxETH).transfer(receiver, assets);
 
-        assets = shares;
+        shares = assets;
     }
 
     function submitAndDeposit(address recipient)

contracts/contracts/mocks/curve/Mock3CRV.sol

@@ -1,16 +1,13 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "../MintableERC20.sol";
+import { ERC20, MintableERC20 } from "../MintableERC20.sol";
+import { BurnableERC20 } from "../BurnableERC20.sol";
 
-contract Mock3CRV is MintableERC20 {
+contract Mock3CRV is MintableERC20, BurnableERC20 {
     constructor() ERC20("Curve.fi DAI/USDC/USDT", "3Crv") {}
 
     function decimals() public pure override returns (uint8) {
         return 18;
     }
-
-    function burnFrom(address from, uint256 value) public {
-        _burn(from, value);
-    }
 }

contracts/contracts/mocks/curve/MockBooster.sol

@@ -9,7 +9,7 @@ import { IRewardStaking } from "../../strategies/IRewardStaking.sol";
 import { IMintableERC20, MintableERC20, ERC20 } from "../MintableERC20.sol";
 import { IBurnableERC20, BurnableERC20 } from "../BurnableERC20.sol";
 
-contract MockDepositToken is MintableERC20 {
+contract MockDepositToken is MintableERC20, BurnableERC20 {
     constructor() ERC20("DCVX", "CVX Deposit Token") {}
 }
 
@@ -37,9 +37,13 @@ contract MockBooster {
         cvx = _cvx;
     }
 
-    function setPool(uint256 pid, address _lpToken) external returns (bool) {
+    function setPool(uint256 pid, address _lpToken)
+        external
+        returns (address rewards)
+    {
         address token = address(new MockDepositToken());
-        address rewards = address(
+        // Deploy a new Convex Rewards Pool
+        rewards = address(
             new MockRewardPool(pid, token, crv, cvx, address(this))
         );
 
@@ -59,66 +63,64 @@ contract MockBooster {
 
         address lptoken = pool.lptoken;
 
-        // hold on to the lptokens
+        // hold on to the Curve LP tokens
         IERC20(lptoken).safeTransferFrom(msg.sender, address(this), _amount);
 
         address token = pool.token;
         if (_stake) {
-            //mint here and send to rewards on user behalf
+            // mint Convex pool LP tokens and stake in rewards contract on user behalf
             IMintableERC20(token).mint(_amount);
             address rewardContract = pool.crvRewards;
             IERC20(token).safeApprove(rewardContract, 0);
             IERC20(token).safeApprove(rewardContract, _amount);
             IRewardStaking(rewardContract).stakeFor(msg.sender, _amount);
         } else {
-            //add user balance directly
+            // mint Convex pool LP tokens and send to user
             IMintableERC20(token).mint(_amount);
             IERC20(token).transfer(msg.sender, _amount);
         }
         return true;
     }
 
-    //deposit all lp tokens and stake
+    // Deposit all Curve LP tokens and stake
     function depositAll(uint256 _pid, bool _stake) external returns (bool) {
         address lptoken = poolInfo[_pid].lptoken;
         uint256 balance = IERC20(lptoken).balanceOf(msg.sender);
         deposit(_pid, balance, _stake);
         return true;
     }
 
-    //withdraw lp tokens
+    // withdraw Curve LP tokens
     function _withdraw(
         uint256 _pid,
         uint256 _amount,
         address _from,
         address _to
     ) internal {
         PoolInfo storage pool = poolInfo[_pid];
-        address lptoken = pool.lptoken;
-        address token = pool.token;
 
-        //remove lp balance
-        IBurnableERC20(token).burnFrom(_from, _amount);
+        // burn the Convex pool LP tokens
+        IBurnableERC20(pool.token).burnFrom(_from, _amount);
 
-        //return lp tokens
-        IERC20(lptoken).safeTransfer(_to, _amount);
+        // return the Curve LP tokens
+        IERC20(pool.lptoken).safeTransfer(_to, _amount);
     }
 
-    //withdraw lp tokens
+    // withdraw Curve LP tokens
     function withdraw(uint256 _pid, uint256 _amount) public returns (bool) {
         _withdraw(_pid, _amount, msg.sender, msg.sender);
         return true;
     }
 
-    //withdraw all lp tokens
+    // withdraw all Curve LP tokens
     function withdrawAll(uint256 _pid) public returns (bool) {
         address token = poolInfo[_pid].token;
         uint256 userBal = IERC20(token).balanceOf(msg.sender);
         withdraw(_pid, userBal);
         return true;
     }
 
-    //allow reward contracts to send here and withdraw to user
+    // allow reward contracts to send here and withdraw to user
     function withdrawTo(
         uint256 _pid,
         uint256 _amount,
@@ -131,7 +133,7 @@ contract MockBooster {
         return true;
     }
 
-    //callback from reward contract when crv is received.
+    // callback from reward contract when crv is received.
     function rewardClaimed(
         uint256 _pid,
         // solhint-disable-next-line no-unused-vars

contracts/contracts/mocks/curve/MockCurveAbstractMetapool.sol

@@ -3,11 +3,9 @@ pragma solidity ^0.8.0;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
-import { IMintableERC20 } from "../MintableERC20.sol";
-import { ICurvePool } from "../../strategies/ICurvePool.sol";
+import { MintableERC20, IMintableERC20 } from "../MintableERC20.sol";
 import { StableMath } from "../../utils/StableMath.sol";
 import "../../utils/Helpers.sol";
-import "../MintableERC20.sol";
 
 abstract contract MockCurveAbstractMetapool is MintableERC20 {
     using StableMath for uint256;
@@ -18,9 +16,8 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
     // Returns the same amount of LP tokens in 1e18 decimals
     function add_liquidity(uint256[2] calldata _amounts, uint256 _minAmount)
         external
-        returns (uint256)
+        returns (uint256 lpAmount)
     {
-        uint256 sum = 0;
         for (uint256 i = 0; i < _amounts.length; i++) {
             if (_amounts[i] > 0) {
                 IERC20(coins[i]).transferFrom(
@@ -30,42 +27,39 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
                 );
                 uint256 assetDecimals = Helpers.getDecimals(coins[i]);
                 // Convert to 1e18 and add to sum
-                sum += _amounts[i].scaleBy(18, assetDecimals);
+                lpAmount += _amounts[i].scaleBy(18, assetDecimals);
                 balances[i] = balances[i] + _amounts[i];
             }
         }
         // Hacky way of simulating slippage to check _minAmount
-        if (sum == 29000e18) sum = 14500e18;
-        require(sum >= _minAmount, "Slippage ruined your day");
+        if (lpAmount == 29000e18) lpAmount = 14500e18;
+        require(lpAmount >= _minAmount, "Slippage ruined your day");
         // Send LP token to sender, e.g. 3CRV
-        mint(sum);
-        transfer(msg.sender, sum);
-        return sum;
+        _mint(msg.sender, lpAmount);
     }
 
     // Dumb implementation that returns the same amount
     function calc_withdraw_one_coin(uint256 _amount, int128 _index)
         public
         view
-        returns (uint256)
+        returns (uint256 lpAmount)
     {
         uint256 assetDecimals = Helpers.getDecimals(coins[uint128(_index)]);
-        return _amount.scaleBy(assetDecimals, 18);
+        lpAmount = _amount.scaleBy(assetDecimals, 18);
     }
 
     function remove_liquidity_one_coin(
-        uint256 _amount,
+        uint256 _lpAmount,
         int128 _index,
         // solhint-disable-next-line no-unused-vars
         uint256 _minAmount
-    ) external {
-        transferFrom(msg.sender, address(this), _amount);
+    ) external returns (uint256 amount) {
+        _burn(msg.sender, _lpAmount);
         uint256[] memory amounts = new uint256[](coins.length);
-        amounts[uint128(_index)] = _amount;
-        uint256 amount = calc_withdraw_one_coin(_amount, _index);
+        amounts[uint128(_index)] = _lpAmount;
+        amount = calc_withdraw_one_coin(_lpAmount, _index);
+        balances[uint128(_index)] -= amount;
         IERC20(coins[uint128(_index)]).transfer(msg.sender, amount);
-        // solhint-disable-next-line reentrancy
-        balances[uint128(_index)] = balances[uint128(_index)] - amount;
     }
 
     function get_virtual_price() external pure returns (uint256) {
@@ -75,30 +69,78 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
     // solhint-disable-next-line no-unused-vars
     function remove_liquidity(uint256 _amount, uint256[2] memory _min_amounts)
         public
+        returns (uint256[2] memory amounts)
     {
-        transferFrom(msg.sender, address(this), _amount);
+        _burn(msg.sender, _amount);
         uint256 totalSupply = totalSupply();
         for (uint256 i = 0; i < 2; i++) {
-            uint256 amount = (_amount / totalSupply) *
-                IERC20(coins[i]).balanceOf(address(this));
-            IERC20(coins[i]).transfer(msg.sender, amount);
-            // solhint-disable-next-line reentrancy
-            balances[i] = balances[i] - amount;
+            amounts[i] = totalSupply > 0
+                ? (_amount / totalSupply) *
+                    IERC20(coins[i]).balanceOf(address(this))
+                : IERC20(coins[i]).balanceOf(address(this));
+            balances[i] -= amounts[i];
+            IERC20(coins[i]).transfer(msg.sender, amounts[i]);
         }
     }
 
     function remove_liquidity_imbalance(
         uint256[2] memory _amounts,
         uint256 _max_burned_tokens
-    ) public {
-        transferFrom(msg.sender, address(this), _max_burned_tokens);
+    ) public returns (uint256) {
+        return
+            _remove_liquidity_imbalance(
+                _amounts,
+                _max_burned_tokens,
+                msg.sender
+            );
+    }
+
+    function remove_liquidity_imbalance(
+        uint256[2] memory _amounts,
+        uint256 _max_burned_tokens,
+        address _reveiver
+    ) public returns (uint256) {
+        return
+            _remove_liquidity_imbalance(
+                _amounts,
+                _max_burned_tokens,
+                _reveiver
+            );
+    }
+
+    function _remove_liquidity_imbalance(
+        uint256[2] memory _amounts,
+        uint256 _max_burned_tokens,
+        address _reveiver
+    ) internal returns (uint256 lpTokens) {
+        lpTokens = _max_burned_tokens;
+        _burn(msg.sender, lpTokens);
+        for (uint256 i = 0; i < _amounts.length; i++) {
+            balances[i] -= _amounts[i];
+            if (_amounts[i] > 0) {
+                IERC20(coins[i]).transfer(_reveiver, _amounts[i]);
+            }
+        }
+    }
+
+    // Dumb implementation that sums the scaled amounts
+    function calc_token_amount(uint256[2] memory _amounts, bool)
+        public
+        view
+        returns (uint256 lpTokens)
+    {
         for (uint256 i = 0; i < _amounts.length; i++) {
-            IERC20(coins[i]).transfer(msg.sender, _amounts[i]);
-            // solhint-disable-next-line reentrancy
-            balances[i] = balances[i] - _amounts[i];
+            uint256 assetDecimals = Helpers.getDecimals(coins[i]);
+            // Convert to 1e18 and add to lpTokens
+            lpTokens += _amounts[i].scaleBy(18, assetDecimals);
         }
     }
 
+    /// @notice 0.02% fee
+    function fee() external pure returns (uint256) {
+        return 2000000;
+    }
+
     function decimals() public pure override returns (uint8) {
         return 18;
     }

contracts/contracts/mocks/curve/MockCurveFrxEthWethPool.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { MockCurveAbstractMetapool } from "./MockCurveAbstractMetapool.sol";
+import "../MintableERC20.sol";
+
+contract MockCurveFrxEthWethPool is MockCurveAbstractMetapool {
+    constructor(address[2] memory _coins)
+        ERC20("Curve.fi Factory Plain Pool: frxETH/WETH", "frxeth-ng-f")
+    {
+        coins = _coins;
+    }
+}

contracts/contracts/mocks/curve/MockCurveGauge.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
-import { ICurveGauge } from "../../strategies/ICurveGauge.sol";
+import { ICurveGauge } from "../../strategies/curve/ICurveGauge.sol";
 
 contract MockCurveGauge is ICurveGauge {
     mapping(address => uint256) private _balances;