WIP: Generalised AMOs for Curve and Balancer

contracts/contracts/interfaces/IVault.sol

@@ -25,6 +25,11 @@ interface IVault {
     event YieldDistribution(address _to, uint256 _yield, uint256 _fee);
     event TrusteeFeeBpsChanged(uint256 _basis);
     event TrusteeAddressChanged(address _address);
+    event AMOStrategyUpdated(address _addr, bool _isAMO);
+    event MintForStrategyThresholdChanged(
+        address _strategy,
+        uint256 _threshold
+    );
     event SwapperChanged(address _address);
     event SwapAllowedUndervalueChanged(uint256 _basis);
     event SwapSlippageChanged(address _asset, uint256 _basis);
@@ -79,8 +84,6 @@ interface IVault {
 
     function trusteeFeeBps() external view returns (uint256);
 
-    function ousdMetaStrategy() external view returns (address);
-
     function setSwapper(address _swapperAddr) external;
 
     function setSwapAllowedUndervalue(uint16 _percentageBps) external;
@@ -189,13 +192,15 @@ interface IVault {
 
     function getAllStrategies() external view returns (address[] memory);
 
-    function isSupportedAsset(address _asset) external view returns (bool);
-
-    function netOusdMintForStrategyThreshold() external view returns (uint256);
+    function getStrategyConfig(address _addr)
+        external
+        view
+        returns (VaultStorage.Strategy memory);
 
-    function setOusdMetaStrategy(address _ousdMetaStrategy) external;
+    function isSupportedAsset(address _asset) external view returns (bool);
 
-    function setNetOusdMintForStrategyThreshold(uint256 _threshold) external;
+    function setAMOStrategy(address _address, bool _isAMO) external;
 
-    function netOusdMintedForStrategy() external view returns (int256);
+    function setMintForStrategyThreshold(address _strategy, uint256 _threshold)
+        external;
 }

contracts/contracts/mocks/curve/MockCurveAbstractMetapool.sol

@@ -10,24 +10,36 @@ import "../../utils/Helpers.sol";
 abstract contract MockCurveAbstractMetapool is MintableERC20 {
     using StableMath for uint256;
 
+    address constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
     address[] public coins;
     uint256[2] public balances;
 
+    function get_balances() external view returns (uint256[2] memory) {
+        return balances;
+    }
+
     // Returns the same amount of LP tokens in 1e18 decimals
     function add_liquidity(uint256[2] calldata _amounts, uint256 _minAmount)
         external
+        payable
         returns (uint256 lpAmount)
     {
         for (uint256 i = 0; i < _amounts.length; i++) {
             if (_amounts[i] > 0) {
-                IERC20(coins[i]).transferFrom(
-                    msg.sender,
-                    address(this),
-                    _amounts[i]
-                );
-                uint256 assetDecimals = Helpers.getDecimals(coins[i]);
-                // Convert to 1e18 and add to sum
-                lpAmount += _amounts[i].scaleBy(18, assetDecimals);
+                if (coins[i] == ETH) {
+                    require(msg.value == _amounts[i], "no ETH sent");
+                    lpAmount += _amounts[i];
+                } else {
+                    IERC20(coins[i]).transferFrom(
+                        msg.sender,
+                        address(this),
+                        _amounts[i]
+                    );
+                    uint256 assetDecimals = Helpers.getDecimals(coins[i]);
+                    // Convert to 1e18 and add to sum
+                    lpAmount += _amounts[i].scaleBy(18, assetDecimals);
+                }
                 balances[i] = balances[i] + _amounts[i];
             }
         }
@@ -39,13 +51,12 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
     }
 
     // Dumb implementation that returns the same amount
-    function calc_withdraw_one_coin(uint256 _amount, int128 _index)
+    function calc_withdraw_one_coin(uint256 _burn_amount, int128)
         public
-        view
-        returns (uint256 lpAmount)
+        pure
+        returns (uint256 coinAmount)
     {
-        uint256 assetDecimals = Helpers.getDecimals(coins[uint128(_index)]);
-        lpAmount = _amount.scaleBy(assetDecimals, 18);
+        coinAmount = _burn_amount;
     }
 
     function remove_liquidity_one_coin(
@@ -54,12 +65,32 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
         // solhint-disable-next-line no-unused-vars
         uint256 _minAmount
     ) external returns (uint256 amount) {
+        amount = remove_liquidity_one_coin(
+            _lpAmount,
+            _index,
+            _minAmount,
+            msg.sender
+        );
+    }
+
+    function remove_liquidity_one_coin(
+        uint256 _lpAmount,
+        int128 _index,
+        // solhint-disable-next-line no-unused-vars
+        uint256 _minAmount,
+        address _receiver
+    ) public returns (uint256 amount) {
         _burn(msg.sender, _lpAmount);
         uint256[] memory amounts = new uint256[](coins.length);
         amounts[uint128(_index)] = _lpAmount;
         amount = calc_withdraw_one_coin(_lpAmount, _index);
         balances[uint128(_index)] -= amount;
-        IERC20(coins[uint128(_index)]).transfer(msg.sender, amount);
+        if (coins[uint128(_index)] == ETH) {
+            require(address(this).balance >= amount, "not enough ETH");
+            payable(_receiver).transfer(amount);
+        } else {
+            IERC20(coins[uint128(_index)]).transfer(_receiver, amount);
+        }
     }
 
     function get_virtual_price() external pure returns (uint256) {
@@ -71,15 +102,21 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
         public
         returns (uint256[2] memory amounts)
     {
-        _burn(msg.sender, _amount);
         uint256 totalSupply = totalSupply();
+        if (totalSupply == 0) return amounts;
+
+        _burn(msg.sender, _amount);
         for (uint256 i = 0; i < 2; i++) {
-            amounts[i] = totalSupply > 0
-                ? (_amount * IERC20(coins[i]).balanceOf(address(this))) /
-                    totalSupply
-                : IERC20(coins[i]).balanceOf(address(this));
             balances[i] -= amounts[i];
-            IERC20(coins[i]).transfer(msg.sender, amounts[i]);
+            if (coins[i] == ETH) {
+                amounts[i] = (_amount * address(this).balance) / totalSupply;
+                payable(msg.sender).transfer(amounts[i]);
+            } else {
+                amounts[i] =
+                    (_amount * IERC20(coins[i]).balanceOf(address(this))) /
+                    totalSupply;
+                IERC20(coins[i]).transfer(msg.sender, amounts[i]);
+            }
         }
     }
 
@@ -118,7 +155,11 @@ abstract contract MockCurveAbstractMetapool is MintableERC20 {
         for (uint256 i = 0; i < _amounts.length; i++) {
             balances[i] -= _amounts[i];
             if (_amounts[i] > 0) {
-                IERC20(coins[i]).transfer(_reveiver, _amounts[i]);
+                if (coins[i] == ETH) {
+                    payable(msg.sender).transfer(_amounts[i]);
+                } else {
+                    IERC20(coins[i]).transfer(_reveiver, _amounts[i]);
+                }
             }
         }
     }

contracts/contracts/mocks/curve/MockCurveFrxEthOethPool.sol

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

contracts/contracts/mocks/curve/MockCurveOethEthPool.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { MockCurveAbstractMetapool } from "./MockCurveAbstractMetapool.sol";
+import "../MintableERC20.sol";
+
+contract MockCurveOethEthPool is MockCurveAbstractMetapool {
+    constructor(address[2] memory _coins)
+        ERC20("Curve.fi Factory Pool: OETH", "OETHCRV-f")
+    {
+        coins = _coins;
+    }
+
+    // TODO need to handle native ETH transfers
+}

contracts/contracts/mocks/curve/MockCurvePool.sol

@@ -30,7 +30,7 @@ contract MockCurvePool {
     function add_liquidity(uint256[3] calldata _amounts, uint256 _minAmount)
         external
     {
-        uint256 sum = 0;
+        uint256 lpAmount = 0;
         for (uint256 i = 0; i < _amounts.length; i++) {
             if (_amounts[i] > 0) {
                 IERC20(coins[i]).transferFrom(
@@ -40,16 +40,16 @@ contract MockCurvePool {
                 );
                 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
-        IMintableERC20(lpToken).mint(sum);
-        IERC20(lpToken).transfer(msg.sender, sum);
+        IMintableERC20(lpToken).mint(lpAmount);
+        IERC20(lpToken).transfer(msg.sender, lpAmount);
     }
 
     // Dumb implementation that returns the same amount
@@ -85,9 +85,9 @@ contract MockCurvePool {
     function remove_liquidity(uint256 _lpAmount, uint256[3] memory _min_amounts)
         public
     {
+        uint256 totalSupply = IERC20(lpToken).totalSupply();
         // Burn the Curve LP tokens
         IBurnableERC20(lpToken).burnFrom(msg.sender, _lpAmount);
-        uint256 totalSupply = IERC20(lpToken).totalSupply();
         for (uint256 i = 0; i < 3; i++) {
             uint256 coinAmount = totalSupply > 0
                 ? (_lpAmount * IERC20(coins[i]).balanceOf(address(this))) /

contracts/contracts/proxies/Proxies.sol

@@ -204,3 +204,10 @@ contract ConvexFrxEthWethStrategyProxy is
 {
 
 }
+
+/**
+ * @notice ConvexFrxETHAMOStrategyProxy delegates calls to a ConvexFrxETHAMOStrategy implementation
+ */
+contract ConvexFrxETHAMOStrategyProxy is InitializeGovernedUpgradeabilityProxy {
+
+}

contracts/contracts/strategies/CompoundStrategy.sol

@@ -217,7 +217,7 @@ contract CompoundStrategy is BaseCompoundStrategy {
      * @notice Approve the spending of all assets by their corresponding cToken,
      *      if for some reason is it necessary.
      */
-    function safeApproveAllTokens() external override {
+    function safeApproveAllTokens() external override onlyGovernor {
         uint256 assetCount = assetsMapped.length;
         for (uint256 i = 0; i < assetCount; ++i) {
             IERC20 asset = IERC20(assetsMapped[i]);