16slim/ve angle

src/AngleStrategyVoterProxy.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity ^0.8.12;
+pragma experimental ABIEncoderV2;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+import {YearnAngleVoter} from "./YearnAngleVoter.sol";
+
+import "./interfaces/curve/ICurve.sol";
+import "./interfaces/Angle/IStableMaster.sol";
+import "./interfaces/Angle/IAngleGauge.sol";
+import "./interfaces/Uniswap/IUniV2.sol";
+
+library SafeVoter {
+    function safeExecute(
+        YearnAngleVoter voter,
+        address to,
+        uint256 value,
+        bytes memory data
+    ) internal {
+        (bool success, ) = voter.execute(to, value, data);
+        require(success);
+    }
+}
+
+contract AngleStrategyVoterProxy {
+    using SafeVoter for YearnAngleVoter;
+    using SafeERC20 for IERC20;
+    using Address for address;
+
+    YearnAngleVoter public yearnAngleVoter;
+    address public constant angle = address(0x31429d1856aD1377A8A0079410B297e1a9e214c2);
+
+    // gauge => strategies
+    mapping(address => address) public strategies;
+    mapping(address => bool) public voters;
+    address public governance;
+
+    uint256 lastTimeCursor;
+
+    constructor(address _voter) public {
+        governance = address(0xFEB4acf3df3cDEA7399794D0869ef76A6EfAff52);
+        yearnAngleVoter = YearnAngleVoter(_voter);
+    }
+
+    function setGovernance(address _governance) external {
+        require(msg.sender == governance, "!governance");
+        governance = _governance;
+    }
+
+    function approveStrategy(address _gauge, address _strategy) external {
+        require(msg.sender == governance, "!governance");
+        strategies[_gauge] = _strategy;
+    }
+
+    function revokeStrategy(address _gauge) external {
+        require(msg.sender == governance, "!governance");
+        strategies[_gauge] = address(0);
+    }
+
+    function approveVoter(address _voter) external {
+        require(msg.sender == governance, "!governance");
+        voters[_voter] = true;
+    }
+
+    function revokeVoter(address _voter) external {
+        require(msg.sender == governance, "!governance");
+        voters[_voter] = false;
+    }
+
+    function lock(uint256 amount, uint256 unlockTime) external {
+        if (amount > 0) {
+            IERC20(angle).transfer(address(yearnAngleVoter), amount);
+            yearnAngleVoter.createLock(amount, unlockTime);
+        }
+    }
+
+    function increaseAmount(uint256 amount) external {
+        if (amount > 0) {
+            IERC20(angle).transfer(address(yearnAngleVoter), amount);
+            yearnAngleVoter.increaseAmount(amount);
+        }
+    }
+
+    function vote(address _gauge, uint256 _amount) public {
+        require(voters[msg.sender], "!voter");
+        yearnAngleVoter.safeExecute(_gauge, 0, abi.encodeWithSignature("vote_for_gauge_weights(address,uint256)", _gauge, _amount));
+    }
+
+    function withdraw(
+        address _gauge,
+        address _token,
+        uint256 _amount
+    ) public returns (uint256) {
+        require(strategies[_gauge] == msg.sender, "!strategy");
+        uint256 _balance = IERC20(_token).balanceOf(address(yearnAngleVoter));
+        yearnAngleVoter.safeExecute(_gauge, 0, abi.encodeWithSignature("withdraw(uint256)", _amount));
+        _balance = IERC20(_token).balanceOf(address(yearnAngleVoter)) - _balance;
+        yearnAngleVoter.safeExecute(_token, 0, abi.encodeWithSignature("transfer(address,uint256)", msg.sender, _balance));
+        return _balance;
+    }
+
+    function withdrawFromStableMaster(address stableMaster, uint256 amount, 
+        address poolManager, address token, address gauge) external {
+        require(strategies[gauge] == msg.sender, "!strategy");
+
+        IERC20(token).safeTransfer(address(yearnAngleVoter), amount);
+
+        yearnAngleVoter.safeExecute(token, 0, abi.encodeWithSignature("approve(address,uint256)", stableMaster, 0));
+        yearnAngleVoter.safeExecute(token, 0, abi.encodeWithSignature("approve(address,uint256)", stableMaster, amount));
+
+        yearnAngleVoter.safeExecute(stableMaster, 0, abi.encodeWithSignature(
+            "withdraw(uint256,address,address,address)", 
+            amount,
+            address(yearnAngleVoter),
+            msg.sender,
+            poolManager
+            ));
+    }
+
+    function balanceOf(address _gauge) public view returns (uint256) {
+        return IERC20(_gauge).balanceOf(address(yearnAngleVoter));
+    }
+
+    function withdrawAll(address _gauge, address _token) external returns (uint256) {
+        require(strategies[_gauge] == msg.sender, "!strategy");
+        return withdraw(_gauge, _token, balanceOf(_gauge));
+    }
+
+    function deposit(address gauge, uint256 amount, address token) external {
+        require(strategies[gauge] == msg.sender, "!strategy");
+
+        yearnAngleVoter.safeExecute(token, 0, abi.encodeWithSignature("approve(address,uint256)", gauge, 0));
+        yearnAngleVoter.safeExecute(token, 0, abi.encodeWithSignature("approve(address,uint256)", gauge, amount));
+
+        yearnAngleVoter.safeExecute(gauge, 0, abi.encodeWithSignature(
+            "deposit(uint256)", 
+            amount
+            ));
+    }
+
+    function depositToStableMaster(address stableMaster, uint256 amount, 
+        address poolManager, address token, address gauge) external {
+        require(strategies[gauge] == msg.sender, "!strategy");
+
+        IERC20(token).safeTransfer(address(yearnAngleVoter), amount);
+
+        yearnAngleVoter.safeExecute(token, 0, abi.encodeWithSignature("approve(address,uint256)", stableMaster, 0));
+        yearnAngleVoter.safeExecute(token, 0, abi.encodeWithSignature("approve(address,uint256)", stableMaster, amount));
+        yearnAngleVoter.safeExecute(stableMaster, 0, abi.encodeWithSignature(
+            "deposit(uint256,address,address)", 
+            amount,
+            address(yearnAngleVoter),
+            poolManager
+            ));
+    }
+
+    function claimRewards(address _gauge, address _token) external {
+        require(strategies[_gauge] == msg.sender, "!strategy");
+        yearnAngleVoter.safeExecute(
+            _gauge, 
+            0, 
+            abi.encodeWithSelector(
+                IAngleGauge.claim_rewards.selector
+            )
+        );
+        yearnAngleVoter.safeExecute(_token, 0, abi.encodeWithSignature("transfer(address,uint256)", msg.sender, IERC20(_token).balanceOf(address(yearnAngleVoter))));
+    }
+
+    function balanceOfSanToken(address sanToken) public view returns (uint256) {
+        return IERC20(sanToken).balanceOf(address(yearnAngleVoter));
+    }
+}

src/Strategy.sol

@@ -18,6 +18,8 @@ import "./interfaces/Angle/IStableMaster.sol";
 import "./interfaces/Angle/IAngleGauge.sol";
 import "./interfaces/Yearn/ITradeFactory.sol";
 import "./interfaces/Uniswap/IUniV2.sol";
+import {AngleStrategyVoterProxy} from "./AngleStrategyVoterProxy.sol";
+
 
 interface IBaseFee {
     function isCurrentBaseFeeAcceptable() external view returns (bool);
@@ -33,6 +35,8 @@ contract Strategy is BaseStrategy {
 
     IERC20 public constant angleToken = IERC20(0x31429d1856aD1377A8A0079410B297e1a9e214c2);
     IStableMaster public constant angleStableMaster = IStableMaster(0x5adDc89785D75C86aB939E9e15bfBBb7Fc086A87);
+    AngleStrategyVoterProxy public strategyProxy;
+
     uint256 public constant MAX_BPS = 10000;
 
     // variable for determining how much governance token to hold for voting rights
@@ -56,13 +60,15 @@ contract Strategy is BaseStrategy {
         address _vault,
         address _sanToken,
         address _sanTokenGauge,
-        address _poolManager
+        address _poolManager,
+        address _strategyProxy
     ) public BaseStrategy(_vault) {
         // Constructor should initialize local variables
         _initializeStrategy(
             _sanToken,
             _sanTokenGauge,
-            _poolManager
+            _poolManager,
+            _strategyProxy
         );
     }
 
@@ -71,11 +77,13 @@ contract Strategy is BaseStrategy {
     function _initializeStrategy(
         address _sanToken,
         address _sanTokenGauge,
-        address _poolManager
+        address _poolManager,
+        address _strategyProxy
     ) internal {
         sanToken = IERC20(_sanToken);
         sanTokenGauge = IAngleGauge(_sanTokenGauge);
         poolManager = _poolManager;
+        strategyProxy = AngleStrategyVoterProxy(_strategyProxy);
 
         percentKeep = 1000;
         healthCheck = 0xDDCea799fF1699e98EDF118e0629A974Df7DF012;
@@ -97,13 +105,15 @@ contract Strategy is BaseStrategy {
         address _keeper,
         address _sanToken,
         address _sanTokenGauge,
-        address _poolManager
+        address _poolManager,
+        address _strategyProxy
     ) external {
         _initialize(_vault, _strategist, _rewards, _keeper);
         _initializeStrategy(
             _sanToken,
             _sanTokenGauge,
-            _poolManager
+            _poolManager,
+            _strategyProxy
         );
     }
 
@@ -114,7 +124,8 @@ contract Strategy is BaseStrategy {
         address _keeper,
         address _sanToken,
         address _sanTokenGauge,
-        address _poolManager
+        address _poolManager,
+        address _strategyProxy
     ) external returns (address newStrategy) {
         require(isOriginal, "!clone");
         bytes20 addressBytes = bytes20(address(this));
@@ -141,7 +152,8 @@ contract Strategy is BaseStrategy {
             _keeper,
             _sanToken,
             _sanTokenGauge,
-            _poolManager
+            _poolManager,
+            _strategyProxy
         );
 
         emit Cloned(newStrategy);
@@ -208,14 +220,14 @@ contract Strategy is BaseStrategy {
         }
 
         // Claim rewards here so that we can chain tend() -> yswap sell -> harvest() in a single transaction
-        sanTokenGauge.claim_rewards();
+        strategyProxy.claimRewards(address(sanTokenGauge), address(angleToken));
 
         uint256 _tokensAvailable = balanceOfAngleToken();
         if (_tokensAvailable > 0) {
-            uint256 _tokensToGov =
+            uint256 _tokensToKeep =
                 (_tokensAvailable * percentKeep) / MAX_BPS;
-            if (_tokensToGov > 0) {
-                angleToken.transfer(treasury, _tokensToGov);
+            if (_tokensToKeep > 0) {
+                IERC20(angleToken).transfer(address(strategyProxy), _tokensToKeep);
             }
         }
 
@@ -230,13 +242,14 @@ contract Strategy is BaseStrategy {
         uint256 _wantAvailable = _balanceOfWant - _debtOutstanding;
         if (_wantAvailable > 0) {
             // deposit for sanToken
+            want.safeTransfer(address(strategyProxy), _wantAvailable);
             depositToStableMaster(_wantAvailable);
         }
 
         // Stake any san tokens, whether they originated through the above deposit or some other means (e.g. migration)
         uint256 _sanTokenBalance = balanceOfSanToken();
         if (_sanTokenBalance > 0) {
-            sanTokenGauge.deposit(_sanTokenBalance);
+            strategyProxy.deposit(address(sanTokenGauge), _sanTokenBalance, address(sanToken));
         }
     }
 
@@ -278,12 +291,16 @@ contract Strategy is BaseStrategy {
 
         uint256 _sanTokenBalance = balanceOfSanToken();
         if (_amountInSanToken > _sanTokenBalance) {
-            sanTokenGauge.withdraw(
-                Math.min(_amountInSanToken - _sanTokenBalance, balanceOfStakedSanToken())
+            _amountInSanToken = Math.min(_amountInSanToken - _sanTokenBalance, balanceOfStakedSanToken());
+            strategyProxy.withdraw(
+                address(sanTokenGauge),
+                address(sanToken),
+                _amountInSanToken
             );
+            IERC20(sanToken).safeTransfer(address(strategyProxy), _amountInSanToken);
         }
 
-        withdrawFromStableMaster(Math.min(_amountInSanToken, balanceOfSanToken()));
+        withdrawFromStableMaster(Math.min(_amountInSanToken, _amountInSanToken));
     }
 
     // can be used in conjunction with migration if this function is still working
@@ -294,9 +311,21 @@ contract Strategy is BaseStrategy {
     // transfers all tokens to new strategy
     function prepareMigration(address _newStrategy) internal override {
         // want is transferred by the base contract's migrate function
-        sanTokenGauge.withdraw(balanceOfStakedSanToken());
+        // sanTokenGauge.withdraw(balanceOfStakedSanToken());
+
+        uint256 _angleBalance = balanceOfAngleToken();
+        if(_angleBalance > 0) {
+            IERC20(angleToken).safeTransfer(_newStrategy, _angleBalance);
+        }
+
+        uint256 _stakedBalance = balanceOfStakedSanToken();
+        if (_stakedBalance > 0) {
+            strategyProxy.withdraw(address(sanTokenGauge), address(sanToken), _stakedBalance);
+            IERC20(sanToken).safeTransfer(address(strategyProxy), _stakedBalance);
+            withdrawFromStableMaster(_stakedBalance);
+        }
 
-        IERC20(sanToken).safeTransfer(_newStrategy, balanceOfSanToken());
+        IERC20(sanToken).safeTransfer(_newStrategy, IERC20(sanToken).balanceOf(address(this)));
         IERC20(angleToken).transfer(_newStrategy, balanceOfAngleToken());
     }
 
@@ -424,19 +453,18 @@ contract Strategy is BaseStrategy {
         percentKeep = _percentKeep;
     }
 
-
     // ----------------- SUPPORT & UTILITY FUNCTIONS ----------
 
     function balanceOfWant() public view returns (uint256) {
         return want.balanceOf(address(this));
     }
 
     function balanceOfStakedSanToken() public view returns (uint256) {
-        return IERC20(address(sanTokenGauge)).balanceOf(address(this));
+        return strategyProxy.balanceOf(address(sanTokenGauge));
     }
 
     function balanceOfSanToken() public view returns (uint256) {
-        return sanToken.balanceOf(address(this));
+        return strategyProxy.balanceOfSanToken(address(sanToken));
     }
 
     function balanceOfAngleToken() public view returns (uint256) {
@@ -472,19 +500,22 @@ contract Strategy is BaseStrategy {
     }
 
     function depositToStableMaster(uint256 _amount) internal {
-        IStableMaster(angleStableMaster).deposit(
+        strategyProxy.depositToStableMaster(
+            address(angleStableMaster),
             _amount,
-            address(this),
-            poolManager
+            poolManager,
+            address(want),
+            address(sanTokenGauge)
         );
     }
 
     function withdrawFromStableMaster(uint256 _amountInSanToken) internal {
-        IStableMaster(angleStableMaster).withdraw(
+        strategyProxy.withdrawFromStableMaster(
+            address(angleStableMaster),
             _amountInSanToken,
-            address(this),
-            address(this),
-            poolManager
+            poolManager,
+            address(sanToken),
+            address(sanTokenGauge)
         );
     }